@zylem/behaviors 0.8.9 → 0.8.11

package/dist/core.js

@@ -15,10 +15,6 @@ import {
   toThreeVector2,
   toThreeVector3
 } from "./chunk-LWM346FW.js";
-import {
-  SyncStateMachine,
-  import_typescript_fsm
-} from "./chunk-OBF6BIA2.js";
 import {
   STAGE_EVENT_STRIDE,
   STAGE_INPUT_BUTTON_JUMP,
@@ -38,10 +34,332 @@ import {
   createWasmStageRuntime,
   readBehaviorSnapshot,
   readStageRenderSlot
-} from "./chunk-GZ3DQIIZ.js";
+} from "./chunk-BR33KT4Z.js";
+import {
+  SyncStateMachine,
+  import_typescript_fsm
+} from "./chunk-CBQSC6W3.js";
+import {
+  PUZZLE_ABILITIES,
+  puzzleCommandData,
+  puzzleData
+} from "./chunk-XNRY6NOC.js";
+import {
+  ADVENTURE_ABILITIES,
+  ADVENTURE_BUTTONS,
+  ADVENTURE_EVENT_KINDS,
+  ADVENTURE_FLAGS
+} from "./chunk-Y5CCNMJI.js";
+import {
+  ENVIRONMENT_ABILITIES,
+  ENVIRONMENT_MODES
+} from "./chunk-DDLZLJ7W.js";
+import {
+  ACROBATICS_ACTIONS,
+  TRAVERSAL_ABILITIES
+} from "./chunk-WF6HC5U3.js";
+import {
+  ClubShotProfileBehavior,
+  GolfRacketBehavior,
+  LandingSpinTransferBehavior,
+  LobAndDropPlacementBehavior,
+  RacketContactTimingBehavior,
+  RacketSpinShotBehavior,
+  RallyPointAdjudicationBehavior,
+  ServeAndFaultSequenceBehavior,
+  SlopeAwarePuttingBehavior,
+  SwingPowerAccuracyBehavior,
+  WindDragBallFlightBehavior
+} from "./chunk-BLTBZJPG.js";
+import {
+  SPORTS_ABILITIES,
+  sportsData,
+  sportsOperation
+} from "./chunk-7IOQEXYR.js";
+import {
+  AirGrabTrickBehavior,
+  LandingAlignmentBailBehavior,
+  ManualBalanceBehavior,
+  PrewoundSpinBehavior,
+  RailGrindBalanceBehavior,
+  RampLipLaunchBehavior,
+  RepeatedTrickDevaluationBehavior,
+  SkateSnowboardBehavior,
+  TrickEarnedBoostMeterBehavior,
+  UnbankedTrickComboBehavior,
+  WallRideBehavior
+} from "./chunk-HQ2UFI3S.js";
+import {
+  SKATE_ABILITIES,
+  skateData,
+  skateOperation
+} from "./chunk-3J3ISPFQ.js";
+import {
+  DriftChargeBoostBehavior,
+  EnergyFundedRaceBoostBehavior,
+  HoverTrackSuspensionBehavior,
+  OrderedLapCheckpointsBehavior,
+  PositionWeightedRaceItemsBehavior,
+  RacingVehiclesBehavior,
+  SlipstreamDraftingBehavior,
+  TrackFollowingHomingItemBehavior,
+  VehicleDamageProgressionBehavior,
+  VehicleSeatEntryExitBehavior,
+  VehicleSideAttackBehavior
+} from "./chunk-C5AYL42A.js";
+import {
+  RACING_ABILITIES,
+  racingData,
+  racingOperation
+} from "./chunk-2UGT4MIF.js";
+import {
+  AdaptiveEncounterPressureBehavior,
+  CompanionAbductionObjectiveBehavior,
+  EncounterClearLockBehavior,
+  EnvironmentalVaultActionBehavior,
+  EscortFollowWaitBehavior,
+  IngredientCombinationBehavior,
+  SavePointCheckpointBehavior,
+  SpatialInventoryPackingBehavior,
+  StaggerFinisherOpportunityBehavior,
+  SurvivalResourcesBehavior,
+  WeaponUpgradeTrackBehavior
+} from "./chunk-73YASAYS.js";
+import {
+  SURVIVAL_ABILITIES,
+  survivalData,
+  survivalOperation
+} from "./chunk-PDHHOVVQ.js";
+import {
+  AlarmCommunicationNetworkBehavior,
+  ContextualDisguiseBehavior,
+  FootprintTrailFollowingBehavior,
+  LastSeenSearchBehavior,
+  NoiseInvestigationBehavior,
+  PedestrianPanicPropagationBehavior,
+  PursuitEvasionDecayBehavior,
+  StealthCityBehavior,
+  TrafficJunctionYieldBehavior,
+  VisionConeAwarenessBehavior,
+  WantedLevelEscalationBehavior
+} from "./chunk-YVVB6YMG.js";
+import {
+  CITY_ABILITIES,
+  CITY_EVENTS,
+  CITY_INTENTS,
+  CITY_LINKS,
+  cityData
+} from "./chunk-5VJIP535.js";
+import {
+  BossPhaseControllerBehavior,
+  CombatAIBehavior,
+  CoverPeekCycleBehavior,
+  GrenadeDangerEvasionBehavior,
+  LatentAmbushActivationBehavior,
+  LeaderLossMoraleBehavior,
+  LocalizedWeakPointDamageBehavior,
+  ShootableProjectileInterceptionBehavior,
+  SquadFlankAssignmentBehavior,
+  TacticalBurstSelectionBehavior,
+  ThreatTargetSelectionBehavior
+} from "./chunk-OH5LJAEJ.js";
+import {
+  ENCOUNTER_ABILITIES,
+  ENCOUNTER_EVENTS,
+  ENCOUNTER_INTENTS,
+  ENCOUNTER_LINKS,
+  encounterData
+} from "./chunk-73MHJY6R.js";
+import {
+  AlternateWeaponModeBehavior,
+  BeamMissileCombinationBehavior,
+  ChargeAndReleaseShotBehavior,
+  DelayedShieldRegenerationBehavior,
+  InterruptibleMagazineReloadBehavior,
+  MaterialPenetratingShotBehavior,
+  RemoteGuidedProjectileBehavior,
+  StationaryAimModeBehavior,
+  StickyGrenadeAttachmentBehavior,
+  WeaponHeatAndVentBehavior,
+  WeaponSystemsBehavior
+} from "./chunk-JFBR4FNX.js";
+import {
+  WEAPON_ABILITIES,
+  WEAPON_EVENTS,
+  WEAPON_PHASES,
+  weaponButtons,
+  weaponData,
+  weaponModeData,
+  weaponProjectileData
+} from "./chunk-GYEKT5AY.js";
+import {
+  COMBAT_ABILITIES,
+  COMBAT_EVENTS,
+  COMBAT_PHASES,
+  combatAttackData,
+  combatButtons,
+  combatData,
+  combatHitData
+} from "./chunk-V4M46BF6.js";
+import {
+  CallAndResponsePatternBehavior,
+  FretChordStrumBehavior,
+  HammerOnPullOffChainBehavior,
+  HoldReleaseRhythmBehavior,
+  PerformanceFailureMeterBehavior,
+  PhraseEarnedScorePowerBehavior,
+  RhythmPerformanceBehavior,
+  RhythmSceneRemixBehavior,
+  SustainNoteTrackingBehavior,
+  TempoMapChartPlayerBehavior,
+  TimestampedRhythmJudgmentBehavior
+} from "./chunk-V26L6MY6.js";
+import {
+  RHYTHM_ABILITIES,
+  RHYTHM_EVENTS,
+  rhythmData,
+  rhythmOperation
+} from "./chunk-LWGJ3QQZ.js";
+import {
+  ActiveBumperKickBehavior,
+  AdjacentPanelSwapBehavior,
+  CascadeChainCreditBehavior,
+  ColumnCollapseBehavior,
+  GarbageBlockConversionBehavior,
+  MatchingPinballBehavior,
+  PinballModeObjectivesBehavior,
+  PoweredPinballFlipperBehavior,
+  RisingStackPressureBehavior,
+  SimultaneousMatchClearBehavior,
+  SpringPlungerLaunchBehavior
+} from "./chunk-EQFLPRF7.js";
+import {
+  MATCHING_ABILITIES,
+  MATCHING_EVENTS,
+  matchingData,
+  matchingOperation
+} from "./chunk-5AJJ44QK.js";
+import {
+  CalendarNpcRoutineBehavior,
+  CropGrowthStagesBehavior,
+  ExertionAndFatigueBehavior,
+  FishingBiteAndHookBehavior,
+  HarvestableFruitRegrowthBehavior,
+  LifeSimulationBehavior,
+  LivestockDailyCareBehavior,
+  RelationshipEventMemoryBehavior,
+  RoomFurniturePlacementBehavior,
+  SeasonalCropEligibilityBehavior,
+  SoilMoistureCycleBehavior
+} from "./chunk-I52PC5IU.js";
+import {
+  LIFE_ABILITIES,
+  LIFE_EVENTS,
+  lifeData,
+  lifeOperation
+} from "./chunk-TZHO6P22.js";
+import {
+  ArmingProximityMineBehavior,
+  BlockerChewTransitionBehavior,
+  BudgetedWaveSchedulerBehavior,
+  BurrowToBacklineBehavior,
+  CostedGridDeploymentBehavior,
+  LaneDefenseBehavior,
+  LaneTargetAcquisitionBehavior,
+  LastChanceLaneSweeperBehavior,
+  LayeredBreakawayArmorBehavior,
+  PeriodicResourceProductionBehavior,
+  SingleUseObstacleVaultBehavior
+} from "./chunk-DRIXFB4C.js";
+import {
+  DEFENSE_ABILITIES,
+  DEFENSE_EVENTS,
+  defenseData,
+  defenseOperation
+} from "./chunk-SFMJNAW3.js";
+import {
+  CooperativeConstructionWorkBehavior,
+  CooperativeObjectTransportBehavior,
+  DayEndUnitRecallBehavior,
+  DeliveredResourceConversionBehavior,
+  GrowthStageMobilityBehavior,
+  SpeciesHazardAffinityBehavior,
+  SquadFormationFollowBehavior,
+  SquadRtsBehavior,
+  SurfaceLatchAttackBehavior,
+  ThrownWorkerDeploymentBehavior,
+  WhistleRecallBehavior
+} from "./chunk-VSFWETXS.js";
+import {
+  SQUAD_ABILITIES,
+  SQUAD_EVENTS,
+  squadData,
+  squadOperation
+} from "./chunk-TSYXRRS4.js";
+import {
+  CommanderPowerWindowBehavior,
+  CounterattackAndFollowUpBehavior,
+  FuelAmmunitionResupplyBehavior,
+  MinMaxAttackRangeBehavior,
+  PersistentUnitLossBehavior,
+  ProgressiveBuildingCaptureBehavior,
+  TacticalGridBehavior,
+  TerrainDefenseModifierBehavior,
+  TerrainMovementBudgetBehavior,
+  TransportLoadUnloadBehavior,
+  WeaponAdvantageCycleBehavior
+} from "./chunk-ZZXTGVGN.js";
+import {
+  TACTICS_ABILITIES,
+  TACTICS_EVENTS,
+  tacticsData,
+  tacticsOperation
+} from "./chunk-6DTIJB7B.js";
+import {
+  ActivePartnerSwapBehavior,
+  BudgetedPassiveLoadoutBehavior,
+  CaptureAttemptResolutionBehavior,
+  ConditionalEvolutionBehavior,
+  EscapeAttemptBehavior,
+  FieldFirstStrikeBehavior,
+  PrioritySpeedTurnOrderBehavior,
+  TimedBattleActionCommandBehavior,
+  TurnBasedRpgBehavior,
+  TurnDurationStatusBehavior,
+  TypeEffectivenessMatrixBehavior
+} from "./chunk-2BE5BW7D.js";
+import {
+  BATTLE_ABILITIES,
+  BATTLE_EVENTS,
+  battleData,
+  battleOperation
+} from "./chunk-LMMF7KXF.js";
+import {
+  ActionRpgBehavior,
+  AffixBudgetGenerationBehavior,
+  AutonomousFamiliarBehavior,
+  ConsumableBeltSlotsBehavior,
+  DamageToResourceLeechBehavior,
+  DeathDropOwnershipBehavior,
+  DurabilityAndRepairBehavior,
+  EquipmentStatAggregationBehavior,
+  ResourceDrainingTransformationBehavior,
+  SeededLootTableBehavior,
+  TypedResistanceResolutionBehavior
+} from "./chunk-3LBGEWT6.js";
+import {
+  RPG_ABILITIES,
+  RPG_EVENTS,
+  rpgData,
+  rpgOperation
+} from "./chunk-VU4LTE2X.js";
 import {
   defineBehavior
-} from "./chunk-YDLO5M7S.js";
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS,
+  getRequiredRuntimeBehaviors
+} from "./chunk-S44ZHYE6.js";
 import "./chunk-JSBRDJBE.js";
 
 // src/lib/capabilities/transform-store.ts
@@ -234,6 +552,401 @@ function freshSlot() {
   };
 }
 var MockBehaviorRuntime = class {
+  attachRhythm(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("rhythm", { abilities, options });
+    return true;
+  }
+  detachRhythm(slot) {
+    return this.slot(slot).attachments.delete("rhythm");
+  }
+  queryRhythm(_slot) {
+    return null;
+  }
+  rhythmAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "rhythm", args: [action] });
+    return true;
+  }
+  attachMatching(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("matching", { abilities, options });
+    return true;
+  }
+  detachMatching(slot) {
+    return this.slot(slot).attachments.delete("matching");
+  }
+  queryMatching(_slot) {
+    return null;
+  }
+  matchingAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "matching", args: [action] });
+    return true;
+  }
+  attachLife(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("life", { abilities, options });
+    return true;
+  }
+  detachLife(slot) {
+    return this.slot(slot).attachments.delete("life");
+  }
+  queryLife(_slot) {
+    return null;
+  }
+  lifeAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "life", args: [action] });
+    return true;
+  }
+  attachDefense(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("defense", { abilities, options });
+    return true;
+  }
+  detachDefense(slot) {
+    return this.slot(slot).attachments.delete("defense");
+  }
+  queryDefense(_slot) {
+    return null;
+  }
+  defenseAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "defense", args: [action] });
+    return true;
+  }
+  attachSquad(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("squad", { abilities, options });
+    return true;
+  }
+  detachSquad(slot) {
+    return this.slot(slot).attachments.delete("squad");
+  }
+  querySquad(_slot) {
+    return null;
+  }
+  squadAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "squad", args: [action] });
+    return true;
+  }
+  attachTactics(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("tactics", { abilities, options });
+    return true;
+  }
+  detachTactics(slot) {
+    return this.slot(slot).attachments.delete("tactics");
+  }
+  queryTactics(_slot) {
+    return null;
+  }
+  tacticsAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "tactics", args: [action] });
+    return true;
+  }
+  attachBattle(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("battle", { abilities, options });
+    return true;
+  }
+  detachBattle(slot) {
+    return this.slot(slot).attachments.delete("battle");
+  }
+  queryBattle(_slot) {
+    return null;
+  }
+  battleAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "battle", args: [action] });
+    return true;
+  }
+  attachRpg(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("rpg", { abilities, options });
+    return true;
+  }
+  detachRpg(slot) {
+    return this.slot(slot).attachments.delete("rpg");
+  }
+  queryRpg(_slot) {
+    return null;
+  }
+  rpgAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "rpg", args: [action] });
+    return true;
+  }
+  attachSports(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("sports", { abilities, options });
+    return true;
+  }
+  detachSports(slot) {
+    return this.slot(slot).attachments.delete("sports");
+  }
+  querySports(_slot) {
+    return null;
+  }
+  sportsAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "sports", args: [action] });
+    return true;
+  }
+  attachSkate(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("skate", { abilities, options });
+    return true;
+  }
+  detachSkate(slot) {
+    return this.slot(slot).attachments.delete("skate");
+  }
+  querySkate(_slot) {
+    return null;
+  }
+  skateAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "skate", args: [action] });
+    return true;
+  }
+  attachRacing(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("racing", { abilities, options });
+    return true;
+  }
+  detachRacing(slot) {
+    return this.slot(slot).attachments.delete("racing");
+  }
+  queryRacing(_slot) {
+    return null;
+  }
+  racingAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "racing", args: [action] });
+    return true;
+  }
+  attachSurvival(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("survival", { abilities, options });
+    return true;
+  }
+  detachSurvival(slot) {
+    return this.slot(slot).attachments.delete("survival");
+  }
+  querySurvival(_slot) {
+    return null;
+  }
+  survivalAction(slot, action) {
+    this.slot(slot).inputs.push({ kind: "survival", args: [action] });
+    return true;
+  }
+  attachCity(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("city", { abilities, options });
+    return true;
+  }
+  detachCity(slot) {
+    return this.slot(slot).attachments.delete("city");
+  }
+  queryCity(slot) {
+    return null;
+  }
+  cityLink(slot, other, kind, data) {
+    this.slot(slot).inputs.push({
+      kind: "city",
+      args: [slot, other, kind, data]
+    });
+    return true;
+  }
+  cityUnlink(slot, other, kind) {
+    this.slot(slot).inputs.push({
+      kind: "city",
+      args: [slot, other, kind]
+    });
+    return true;
+  }
+  cityCommand(slot, kind, data) {
+    this.slot(slot).inputs.push({ kind: "city", args: [slot, kind, data] });
+    return true;
+  }
+  citySignal(slot, source, kind, sequence, data) {
+    this.slot(slot).inputs.push({
+      kind: "city",
+      args: [slot, source, kind, sequence, data]
+    });
+    return true;
+  }
+  attachEncounters(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("encounter", { abilities, options });
+    return true;
+  }
+  detachEncounters(slot) {
+    return this.slot(slot).attachments.delete("encounter");
+  }
+  queryEncounters(slot) {
+    return null;
+  }
+  encounterLink(slot, other, kind, data) {
+    this.slot(slot).inputs.push({
+      kind: "encounter",
+      args: [slot, other, kind, data]
+    });
+    return true;
+  }
+  encounterUnlink(slot, other, kind) {
+    this.slot(slot).inputs.push({
+      kind: "encounter",
+      args: [slot, other, kind]
+    });
+    return true;
+  }
+  encounterCommand(slot, kind, value, data = []) {
+    this.slot(slot).inputs.push({
+      kind: "encounter",
+      args: [slot, kind, value, data]
+    });
+    return true;
+  }
+  encounterHit(slot, source, region, hit) {
+    this.slot(slot).inputs.push({
+      kind: "encounter",
+      args: [slot, source, region, hit]
+    });
+    return true;
+  }
+  attachWeapons(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("weapon", { abilities, options });
+    return true;
+  }
+  detachWeapons(slot) {
+    return this.slot(slot).attachments.delete("weapon");
+  }
+  queryWeapons(_slot) {
+    return null;
+  }
+  weaponInput(slot, input) {
+    this.slot(slot).inputs.push({ kind: "weapon", args: [input] });
+    return true;
+  }
+  weaponMode(slot, index, mode) {
+    this.slot(slot).attachments.set("weapon-mode-" + index, mode);
+    return true;
+  }
+  weaponDamage(slot, amount, source) {
+    this.slot(slot).inputs.push({ kind: "weapon-damage", args: [amount, source] });
+    return true;
+  }
+  weaponSurface(slot, surface) {
+    this.slot(slot).attachments.set("weapon-surface", surface);
+    return true;
+  }
+  launchWeaponProjectile(owner, slot, kind, options = {}) {
+    this.slot(slot).attachments.set("weapon-projectile", { owner, kind, options });
+    return true;
+  }
+  queryWeaponProjectile(_slot) {
+    return null;
+  }
+  weaponCameraIntent(_slot) {
+    return null;
+  }
+  attachCombat(slot, abilities, options = {}) {
+    this.slot(slot).attachments.set("combat", { abilities, options });
+    return true;
+  }
+  detachCombat(slot) {
+    return this.slot(slot).attachments.delete("combat");
+  }
+  queryCombat(_slot) {
+    return null;
+  }
+  combatInput(slot, input) {
+    this.slot(slot).inputs.push({ kind: "combat", args: [input] });
+    return true;
+  }
+  combatAttack(slot, index, attack) {
+    this.slot(slot).attachments.set("combat-attack-" + index, attack);
+    return true;
+  }
+  combatHit(slot, hit, source) {
+    this.slot(slot).inputs.push({ kind: "combat-hit", args: [hit, source] });
+    return true;
+  }
+  attachPuzzle(slot, ability, options = {}) {
+    this.slot(slot).attachments.set("puzzle", { ability, options });
+    return true;
+  }
+  detachPuzzle(slot) {
+    return this.slot(slot).attachments.delete("puzzle");
+  }
+  queryPuzzle(_slot) {
+    return null;
+  }
+  puzzleCommand(slot, command) {
+    this.slot(slot).inputs.push({ kind: "puzzle", args: [command] });
+    return true;
+  }
+  puzzleLink(_slot, _other) {
+    return true;
+  }
+  puzzleSegments(_slot) {
+    return [];
+  }
+  attachAdventure(slot, abilities, options = {}) {
+    if (this.slot(slot).attachments.has("adventure")) return false;
+    this.slot(slot).attachments.set("adventure", { abilities, ...options });
+    return true;
+  }
+  detachAdventure(slot) {
+    return this.slot(slot).attachments.delete("adventure");
+  }
+  queryAdventure(_slot) {
+    return null;
+  }
+  writeAdventureInput(slot, input) {
+    this.slot(slot).attachments.set("adventure-input", input);
+  }
+  setAdventureObject(slot, object) {
+    this.slot(slot).attachments.set("adventure-object", object);
+    return true;
+  }
+  queryAdventureObject(_slot) {
+    return null;
+  }
+  adventureProgress(_slot, _kind, _key, _value = 0) {
+    return 0;
+  }
+  attachEnvironment(slot, abilities, options = {}) {
+    if (this.slot(slot).attachments.has("environment")) return false;
+    this.slot(slot).attachments.set("environment", { abilities, ...options });
+    return true;
+  }
+  detachEnvironment(slot) {
+    return this.slot(slot).attachments.delete("environment");
+  }
+  queryEnvironment(_slot) {
+    return null;
+  }
+  writeEnvironmentInput(slot, input) {
+    this.writeInputAxes(slot, input.moveX ?? 0, input.moveY ?? 0);
+    this.writeInputLook(slot, input.moveZ ?? 0, input.sailTrim ?? 0);
+    [input.stroke, input.breach, input.glide, input.sail, input.ride, input.release].forEach((v, i) => this.writeInputButton(slot, 1 << i, !!v));
+  }
+  setEnvironmentVolume(slot, volume) {
+    this.slot(slot).attachments.set("environment-volume", volume);
+    return true;
+  }
+  setTubeRail(slot, rail) {
+    this.slot(slot).attachments.set("tube-rail", rail);
+    return true;
+  }
+  attachAcrobatics(slot, abilities, options = {}) {
+    if (this.slot(slot).attachments.has("acrobatics")) return false;
+    this.slot(slot).attachments.set("acrobatics", { abilities, ...options });
+    return true;
+  }
+  setTraversalSurface(slot, kind) {
+    this.slot(slot).attachments.set("traversal-surface", kind);
+    return true;
+  }
+  setPossessable(slot, enabled) {
+    this.slot(slot).attachments.set("possessable", enabled);
+    return true;
+  }
+  startPossession(_owner, _target, _seconds = 5) {
+    return false;
+  }
+  endPossession(_owner) {
+    return false;
+  }
+  queryPossession(_owner) {
+    return null;
+  }
+  queryAcrobatics(_slot) {
+    return null;
+  }
+  detachAcrobatics(slot) {
+    return this.slot(slot).attachments.delete("acrobatics");
+  }
   slots = /* @__PURE__ */ new Map();
   slot(handle) {
     let state = this.slots.get(handle);
@@ -600,6 +1313,66 @@ var Simulation = class {
         case StageEventType.Wrapped:
           out.push({ type: "wrapped", entity: primary, axes: event.payload[0] | 0 });
           break;
+        case StageEventType.Rhythm:
+          out.push({ type: "rhythm", entity: primary, target: secondary, kind: RHYTHM_EVENTS[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Matching:
+          out.push({ type: "matching", entity: primary, target: secondary, kind: MATCHING_EVENTS[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Life:
+          out.push({ type: "life", entity: primary, target: secondary, kind: LIFE_EVENTS[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Defense:
+          out.push({ type: "defense", entity: primary, target: secondary, kind: DEFENSE_EVENTS[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Squad:
+          out.push({ type: "squad", entity: primary, target: secondary, kind: SQUAD_EVENTS[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Tactics:
+          out.push({ type: "tactics", entity: primary, target: secondary, kind: TACTICS_EVENTS[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Battle:
+          out.push({ type: "battle", entity: primary, target: secondary, kind: BATTLE_EVENTS[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Rpg:
+          out.push({ type: "rpg", entity: primary, target: secondary, kind: RPG_EVENTS[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Sports:
+          out.push({ type: "sports", entity: primary, target: secondary, kind: SPORTS_ABILITIES[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Skate:
+          out.push({ type: "skate", entity: primary, target: secondary, kind: SKATE_ABILITIES[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Racing:
+          out.push({ type: "racing", entity: primary, target: secondary, kind: RACING_ABILITIES[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.Survival:
+          out.push({ type: "survival", entity: primary, target: secondary, kind: SURVIVAL_ABILITIES[event.payload[0] - 1], value: event.payload[1] });
+          break;
+        case StageEventType.City:
+          out.push({ type: "city", entity: primary, target: secondary, kind: CITY_EVENTS[event.payload[0]] ?? "none", value: event.payload[1] });
+          break;
+        case StageEventType.Encounter:
+          out.push({ type: "encounter", entity: primary, target: secondary, kind: ENCOUNTER_EVENTS[event.payload[0]] ?? "none", value: event.payload[1] });
+          break;
+        case StageEventType.Weapon:
+          out.push({ type: "weapon", entity: primary, target: secondary, kind: WEAPON_EVENTS[event.payload[0]] ?? "none", value: event.payload[1] });
+          break;
+        case StageEventType.Combat:
+          out.push({ type: "combat", entity: primary, target: secondary, kind: COMBAT_EVENTS[event.payload[0]] ?? "none", value: event.payload[1] });
+          break;
+        case StageEventType.Puzzle:
+          out.push({ type: "puzzle", entity: primary, ability: PUZZLE_ABILITIES[event.payload[0] - 1], active: event.payload[1] === 1, value: event.payload[2] });
+          break;
+        case StageEventType.Adventure:
+          out.push({ type: "adventure", entity: primary, target: secondary, kind: ADVENTURE_EVENT_KINDS[event.payload[0]] ?? "unknown", value: event.payload[1] });
+          break;
+        case StageEventType.DrowningDamage:
+          out.push({ type: "drowningDamage", entity: primary, amount: event.payload[0], total: event.payload[1], severity: event.payload[2] });
+          break;
+        case StageEventType.GroundPoundImpact:
+          out.push({ type: "groundPoundImpact", entity: primary, speed: event.payload[0], count: event.payload[1] });
+          break;
         case StageEventType.CooldownFired:
           out.push({ type: "cooldownFired", entity: primary, cooldownId: event.payload[0] | 0 });
           break;
@@ -612,6 +1385,564 @@ var Simulation = class {
   getPose(handle, out) {
     return this.adapter.getPose(handle.slot, out);
   }
+  /** These ownership APIs require live handles from this Simulation. */
+  live(handle) {
+    return !this.disposed && this.idToHandle.get(handle.id) === handle;
+  }
+  attachRhythm(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachRhythm(handle.slot, abilities, options);
+  }
+  detachRhythm(handle) {
+    return this.live(handle) && this.adapter.detachRhythm(handle.slot);
+  }
+  getRhythmState(handle) {
+    return this.live(handle) ? this.adapter.queryRhythm(handle.slot) : null;
+  }
+  rhythmAction(handle, action) {
+    if (!this.live(handle)) return false;
+    return this.adapter.rhythmAction(handle.slot, action);
+  }
+  attachMatching(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachMatching(handle.slot, abilities, options);
+  }
+  detachMatching(handle) {
+    return this.live(handle) && this.adapter.detachMatching(handle.slot);
+  }
+  getMatchingState(handle) {
+    return this.live(handle) ? this.adapter.queryMatching(handle.slot) : null;
+  }
+  matchingAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.matchingAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.matchingAction(handle.slot, action);
+  }
+  attachLife(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachLife(handle.slot, abilities, options);
+  }
+  detachLife(handle) {
+    return this.live(handle) && this.adapter.detachLife(handle.slot);
+  }
+  getLifeState(handle) {
+    return this.live(handle) ? this.adapter.queryLife(handle.slot) : null;
+  }
+  lifeAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.lifeAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.lifeAction(handle.slot, action);
+  }
+  attachDefense(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachDefense(handle.slot, abilities, options);
+  }
+  detachDefense(handle) {
+    return this.live(handle) && this.adapter.detachDefense(handle.slot);
+  }
+  getDefenseState(handle) {
+    return this.live(handle) ? this.adapter.queryDefense(handle.slot) : null;
+  }
+  defenseAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.defenseAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.defenseAction(handle.slot, action);
+  }
+  attachSquad(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachSquad(handle.slot, abilities, options);
+  }
+  detachSquad(handle) {
+    return this.live(handle) && this.adapter.detachSquad(handle.slot);
+  }
+  getSquadState(handle) {
+    return this.live(handle) ? this.adapter.querySquad(handle.slot) : null;
+  }
+  squadAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.squadAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.squadAction(handle.slot, action);
+  }
+  attachTactics(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachTactics(handle.slot, abilities, options);
+  }
+  detachTactics(handle) {
+    return this.live(handle) && this.adapter.detachTactics(handle.slot);
+  }
+  getTacticsState(handle) {
+    return this.live(handle) ? this.adapter.queryTactics(handle.slot) : null;
+  }
+  tacticsAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.tacticsAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.tacticsAction(handle.slot, action);
+  }
+  attachBattle(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachBattle(handle.slot, abilities, options);
+  }
+  detachBattle(handle) {
+    return this.live(handle) && this.adapter.detachBattle(handle.slot);
+  }
+  getBattleState(handle) {
+    return this.live(handle) ? this.adapter.queryBattle(handle.slot) : null;
+  }
+  battleAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.battleAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.battleAction(handle.slot, action);
+  }
+  attachRpg(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachRpg(handle.slot, abilities, options);
+  }
+  detachRpg(handle) {
+    return this.live(handle) && this.adapter.detachRpg(handle.slot);
+  }
+  getRpgState(handle) {
+    return this.live(handle) ? this.adapter.queryRpg(handle.slot) : null;
+  }
+  rpgAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.rpgAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.rpgAction(handle.slot, action);
+  }
+  attachSports(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachSports(handle.slot, abilities, options);
+  }
+  detachSports(handle) {
+    return this.live(handle) && this.adapter.detachSports(handle.slot);
+  }
+  getSportsState(handle) {
+    return this.live(handle) ? this.adapter.querySports(handle.slot) : null;
+  }
+  sportsAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.sportsAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.sportsAction(handle.slot, action);
+  }
+  attachSkate(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachSkate(handle.slot, abilities, options);
+  }
+  detachSkate(handle) {
+    return this.live(handle) && this.adapter.detachSkate(handle.slot);
+  }
+  getSkateState(handle) {
+    return this.live(handle) ? this.adapter.querySkate(handle.slot) : null;
+  }
+  skateAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.skateAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.skateAction(handle.slot, action);
+  }
+  attachRacing(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachRacing(handle.slot, abilities, options);
+  }
+  detachRacing(handle) {
+    return this.live(handle) && this.adapter.detachRacing(handle.slot);
+  }
+  getRacingState(handle) {
+    return this.live(handle) ? this.adapter.queryRacing(handle.slot) : null;
+  }
+  racingAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.racingAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.racingAction(handle.slot, action);
+  }
+  attachSurvival(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachSurvival(handle.slot, abilities, options);
+  }
+  detachSurvival(handle) {
+    return this.live(handle) && this.adapter.detachSurvival(handle.slot);
+  }
+  getSurvivalState(handle) {
+    return this.live(handle) ? this.adapter.querySurvival(handle.slot) : null;
+  }
+  survivalAction(handle, action) {
+    if (!this.live(handle)) return false;
+    if ("target" in action) {
+      if (!this.live(action.target)) return false;
+      return this.adapter.survivalAction(handle.slot, {
+        ...action,
+        target: action.target.slot
+      });
+    }
+    return this.adapter.survivalAction(handle.slot, action);
+  }
+  attachCity(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachCity(handle.slot, abilities, options);
+  }
+  detachCity(handle) {
+    return this.live(handle) && this.adapter.detachCity(handle.slot);
+  }
+  getCityState(handle) {
+    return this.live(handle) ? this.adapter.queryCity(handle.slot) : null;
+  }
+  cityLink(handle, other, kind, data) {
+    return this.live(handle) && this.live(other) && this.adapter.cityLink(handle.slot, other.slot, kind, data);
+  }
+  setCityTarget(handle, target, o = {}) {
+    return this.cityLink(handle, target, 0, [
+      o.exposure ?? 1,
+      o.crouched ? 1 : 0,
+      o.zone ?? 0,
+      o.disguiseZone ?? 0,
+      o.disguised ? 1 : 0,
+      o.actions ?? 0,
+      o.recognized ? 1 : 0
+    ]);
+  }
+  connectCityRadio(handle, receiver, channel = 0) {
+    return this.cityLink(handle, receiver, 1, [channel]);
+  }
+  addCityNeighbor(handle, neighbor) {
+    return this.cityLink(handle, neighbor, 2, []);
+  }
+  setCityJunction(handle, junction, exit, priority = 0) {
+    return this.cityLink(handle, junction, 3, [...exit, priority]);
+  }
+  addCityObserver(handle, observer) {
+    return this.cityLink(handle, observer, 4, []);
+  }
+  removeCityLink(handle, other, kind) {
+    return this.live(handle) && this.live(other) && this.adapter.cityUnlink(
+      handle.slot,
+      other.slot,
+      CITY_LINKS.indexOf(kind)
+    );
+  }
+  cityCommand(handle, kind, data) {
+    return this.live(handle) && this.adapter.cityCommand(handle.slot, kind, data);
+  }
+  setCityFacing(handle, direction) {
+    return this.cityCommand(handle, 0, direction);
+  }
+  interruptCityReport(handle) {
+    return this.cityCommand(handle, 1, []);
+  }
+  setCityPursuitConditions(handle, observed, inSearchZone) {
+    return this.cityCommand(handle, 2, [
+      observed ? 1 : 0,
+      inSearchZone ? 1 : 0
+    ]);
+  }
+  /** Initialization only: seed B078 without needing B077. */
+  setCityPursuitScore(handle, score) {
+    return this.cityCommand(handle, 3, [score]);
+  }
+  setCityTraffic(handle, input) {
+    return this.cityCommand(handle, 4, [
+      input.green ? 1 : 0,
+      input.exitOpen ? 1 : 0,
+      input.request ? 1 : 0,
+      input.inside ? 1 : 0
+    ]);
+  }
+  setCityHearingMask(handle, mask) {
+    return this.cityCommand(handle, 5, [mask]);
+  }
+  /** Initialization only, six strictly ascending thresholds, zero-based index. */
+  setCityResponseTier(handle, index, threshold, responseMask) {
+    return this.cityCommand(handle, 6, [index, threshold, responseMask]);
+  }
+  citySignal(handle, source, kind, sequence, data) {
+    return this.live(handle) && this.live(source) && this.adapter.citySignal(
+      handle.slot,
+      source.slot,
+      kind,
+      sequence,
+      data
+    );
+  }
+  emitCityNoise(handle, source, o) {
+    return this.citySignal(handle, source, 0, o.sequence, [
+      ...o.position,
+      o.loudness ?? 1,
+      ["footstep", "impact", "gunshot"].indexOf(o.category ?? "footstep"),
+      o.age ?? 0
+    ]);
+  }
+  addCityFootprint(handle, source, o) {
+    return this.citySignal(handle, source, 1, o.sequence, [
+      ...o.position,
+      o.age ?? 0,
+      o.eligible === false ? 0 : 1
+    ]);
+  }
+  startCityReport(handle, sequence, channel = 0) {
+    return this.citySignal(handle, handle, 2, sequence, [channel]);
+  }
+  reportCityOffense(handle, witness, sequence, severity) {
+    return this.citySignal(handle, witness, 3, sequence, [severity]);
+  }
+  emitCityDanger(handle, source, o) {
+    return this.citySignal(handle, source, 4, o.sequence, [
+      ...o.position,
+      o.radius ?? 10,
+      o.age ?? 0
+    ]);
+  }
+  attachEncounters(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachEncounters(handle.slot, abilities, options);
+  }
+  detachEncounters(handle) {
+    return this.live(handle) && this.adapter.detachEncounters(handle.slot);
+  }
+  getEncounterState(handle) {
+    return this.live(handle) ? this.adapter.queryEncounters(handle.slot) : null;
+  }
+  encounterLink(handle, other, kind, data) {
+    return this.live(handle) && this.live(other) && this.adapter.encounterLink(handle.slot, other.slot, kind, data);
+  }
+  setEncounterCandidate(handle, other, options = {}) {
+    return this.encounterLink(handle, other, 0, [
+      options.team ?? 2,
+      options.priority ?? 0,
+      options.recentDamage ?? 0
+    ]);
+  }
+  setEncounterLeader(handle, leader) {
+    return this.encounterLink(handle, leader, 1, []);
+  }
+  addEncounterAlly(handle, ally) {
+    return this.encounterLink(handle, ally, 2, []);
+  }
+  setEncounterCover(handle, anchor, options) {
+    return this.encounterLink(handle, anchor, 3, [
+      ...options.hide,
+      ...options.peek
+    ]);
+  }
+  setEncounterHazard(handle, source, options) {
+    return this.encounterLink(handle, source, 4, [
+      options.radius,
+      options.fuse,
+      ...options.velocity ?? [0, 0, 0]
+    ]);
+  }
+  setEncounterRegion(handle, region, options = {}) {
+    return this.encounterLink(handle, region, 5, [
+      options.multiplier ?? 2,
+      options.staggerThreshold ?? 20
+    ]);
+  }
+  removeEncounterLink(handle, other, kind) {
+    return this.live(handle) && this.live(other) && this.adapter.encounterUnlink(
+      handle.slot,
+      other.slot,
+      ENCOUNTER_LINKS.indexOf(kind)
+    );
+  }
+  triggerEncounter(handle) {
+    return this.live(handle) && this.adapter.encounterCommand(handle.slot, 0, 1);
+  }
+  advanceEncounterPhase(handle, phase) {
+    return this.live(handle) && this.adapter.encounterCommand(handle.slot, 1, phase);
+  }
+  setEncounterShotBudget(handle, count) {
+    return this.live(handle) && this.adapter.encounterCommand(handle.slot, 2, count);
+  }
+  setEncounterPhase(handle, index, phase) {
+    return this.live(handle) && this.adapter.encounterCommand(handle.slot, 3, index, [
+      phase.healthFraction,
+      phase.attackMask,
+      phase.vulnerability ?? 1
+    ]);
+  }
+  applyEncounterHit(handle, source, hit, region = null) {
+    return this.live(handle) && this.live(source) && (region === null || this.live(region)) && this.adapter.encounterHit(
+      handle.slot,
+      source.slot,
+      region?.slot ?? null,
+      hit
+    );
+  }
+  attachWeapons(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachWeapons(handle.slot, abilities, options);
+  }
+  detachWeapons(handle) {
+    return this.live(handle) && this.adapter.detachWeapons(handle.slot);
+  }
+  setWeaponInput(handle, input) {
+    return this.live(handle) && this.adapter.weaponInput(handle.slot, input);
+  }
+  setWeaponMode(handle, index, mode) {
+    return this.live(handle) && this.adapter.weaponMode(handle.slot, index, mode);
+  }
+  applyWeaponDamage(handle, amount, source = null) {
+    return this.live(handle) && (source === null || this.live(source)) && this.adapter.weaponDamage(handle.slot, amount, source?.slot ?? null);
+  }
+  setWeaponSurface(handle, surface) {
+    return this.live(handle) && this.adapter.weaponSurface(handle.slot, surface);
+  }
+  launchWeaponProjectile(owner, projectile, kind, options = {}) {
+    return this.live(owner) && this.live(projectile) && this.adapter.launchWeaponProjectile(owner.slot, projectile.slot, kind, options);
+  }
+  getWeaponState(handle) {
+    return this.live(handle) ? this.adapter.queryWeapons(handle.slot) : null;
+  }
+  getWeaponProjectileState(handle) {
+    return this.live(handle) ? this.adapter.queryWeaponProjectile(handle.slot) : null;
+  }
+  getWeaponCameraIntent(handle) {
+    return this.live(handle) ? this.adapter.weaponCameraIntent(handle.slot) : null;
+  }
+  attachCombat(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachCombat(handle.slot, abilities, options);
+  }
+  detachCombat(handle) {
+    return this.live(handle) && this.adapter.detachCombat(handle.slot);
+  }
+  setCombatInput(handle, input) {
+    return this.live(handle) && this.adapter.combatInput(handle.slot, input);
+  }
+  setCombatAttack(handle, index, attack) {
+    return this.live(handle) && this.adapter.combatAttack(handle.slot, index, attack);
+  }
+  applyCombatHit(handle, hit = {}, source = null) {
+    return this.live(handle) && (source === null || this.live(source)) && this.adapter.combatHit(handle.slot, hit, source?.slot ?? null);
+  }
+  getCombatState(handle) {
+    return this.live(handle) ? this.adapter.queryCombat(handle.slot) : null;
+  }
+  attachPuzzle(handle, ability, options = {}) {
+    return this.live(handle) && this.adapter.attachPuzzle(handle.slot, ability, options);
+  }
+  detachPuzzle(handle) {
+    return this.live(handle) && this.adapter.detachPuzzle(handle.slot);
+  }
+  getPuzzleState(handle) {
+    return this.live(handle) ? this.adapter.queryPuzzle(handle.slot) : null;
+  }
+  sendPuzzleCommand(handle, command) {
+    return this.live(handle) && this.adapter.puzzleCommand(handle.slot, command);
+  }
+  setPuzzleLink(handle, other) {
+    return this.live(handle) && (other === null || this.live(other)) && this.adapter.puzzleLink(handle.slot, other?.slot ?? null);
+  }
+  getPuzzleSegments(handle) {
+    return this.live(handle) ? this.adapter.puzzleSegments(handle.slot) : [];
+  }
+  attachAdventure(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachAdventure(handle.slot, abilities, options);
+  }
+  detachAdventure(handle) {
+    return this.live(handle) && this.adapter.detachAdventure(handle.slot);
+  }
+  getAdventureState(handle) {
+    return this.live(handle) ? this.adapter.queryAdventure(handle.slot) : null;
+  }
+  setAdventureInput(handle, input) {
+    if (!this.live(handle)) return false;
+    this.adapter.writeAdventureInput(handle.slot, input);
+    return true;
+  }
+  setAdventureObject(handle, object) {
+    return this.live(handle) && this.adapter.setAdventureObject(handle.slot, object);
+  }
+  getAdventureObjectState(handle) {
+    return this.live(handle) ? this.adapter.queryAdventureObject(handle.slot) : null;
+  }
+  grantAdventureToken(handle, key, count = 1) {
+    return this.live(handle) ? this.adapter.adventureProgress(handle.slot, 1, key, count) : 0;
+  }
+  getAdventureToken(handle, key) {
+    return this.live(handle) ? this.adapter.adventureProgress(handle.slot, 0, key) : 0;
+  }
+  hasAdventureDiscovery(handle, key) {
+    return this.live(handle) && this.adapter.adventureProgress(handle.slot, 2, key) === 1;
+  }
+  attachEnvironment(handle, abilities, options = {}) {
+    return this.live(handle) && this.adapter.attachEnvironment(handle.slot, abilities, options);
+  }
+  detachEnvironment(handle) {
+    return this.live(handle) && this.adapter.detachEnvironment(handle.slot);
+  }
+  getEnvironmentState(handle) {
+    return this.live(handle) ? this.adapter.queryEnvironment(handle.slot) : null;
+  }
+  setEnvironmentInput(handle, input) {
+    if (!this.live(handle)) return false;
+    this.adapter.writeEnvironmentInput(handle.slot, input);
+    return true;
+  }
+  setEnvironmentVolume(handle, volume) {
+    return this.live(handle) && this.adapter.setEnvironmentVolume(handle.slot, volume);
+  }
+  setTubeRail(handle, rail) {
+    return this.live(handle) && this.adapter.setTubeRail(handle.slot, rail);
+  }
+  setTraversalSurface(handle, kind) {
+    return this.live(handle) && this.adapter.setTraversalSurface(handle.slot, kind);
+  }
+  setPossessable(handle, enabled) {
+    return this.live(handle) && this.adapter.setPossessable(handle.slot, enabled);
+  }
+  startPossession(owner, target, seconds = 5) {
+    return this.live(owner) && this.live(target) && this.adapter.startPossession(owner.slot, target.slot, seconds);
+  }
+  endPossession(owner) {
+    return this.live(owner) && this.adapter.endPossession(owner.slot);
+  }
+  getPossession(owner) {
+    if (!this.live(owner)) return null;
+    const session = this.adapter.queryPossession(owner.slot);
+    const target = session && this.slotToHandle.get(session.targetSlot);
+    return session && target ? { target, remaining: session.remaining } : null;
+  }
   setPosition(handle, x, y, z) {
     return this.adapter.setPosition(handle.slot, x, y, z);
   }
@@ -754,8 +2085,155 @@ var GameEntity = class {
 };
 var export_t = import_typescript_fsm.t;
 export {
+  ACROBATICS_ACTIONS,
+  ADVENTURE_ABILITIES,
+  ADVENTURE_BUTTONS,
+  ADVENTURE_EVENT_KINDS,
+  ADVENTURE_FLAGS,
+  ActionRpgBehavior,
+  ActiveBumperKickBehavior,
+  ActivePartnerSwapBehavior,
+  AdaptiveEncounterPressureBehavior,
+  AdjacentPanelSwapBehavior,
+  AffixBudgetGenerationBehavior,
+  AirGrabTrickBehavior,
+  AlarmCommunicationNetworkBehavior,
+  AlternateWeaponModeBehavior,
+  ArmingProximityMineBehavior,
+  AutonomousFamiliarBehavior,
+  BATTLE_ABILITIES,
+  BATTLE_EVENTS,
+  BUILTIN_BEHAVIORS,
+  BeamMissileCombinationBehavior,
+  BlockerChewTransitionBehavior,
+  BossPhaseControllerBehavior,
+  BudgetedPassiveLoadoutBehavior,
+  BudgetedWaveSchedulerBehavior,
+  BurrowToBacklineBehavior,
+  CITY_ABILITIES,
+  CITY_EVENTS,
+  CITY_INTENTS,
+  CITY_LINKS,
+  COMBAT_ABILITIES,
+  COMBAT_EVENTS,
+  COMBAT_PHASES,
+  CalendarNpcRoutineBehavior,
+  CallAndResponsePatternBehavior,
+  CaptureAttemptResolutionBehavior,
+  CascadeChainCreditBehavior,
+  ChargeAndReleaseShotBehavior,
+  ClubShotProfileBehavior,
+  ColumnCollapseBehavior,
+  CombatAIBehavior,
+  CommanderPowerWindowBehavior,
+  CompanionAbductionObjectiveBehavior,
+  ConditionalEvolutionBehavior,
+  ConsumableBeltSlotsBehavior,
+  ContextualDisguiseBehavior,
+  CooperativeConstructionWorkBehavior,
+  CooperativeObjectTransportBehavior,
+  CostedGridDeploymentBehavior,
+  CounterattackAndFollowUpBehavior,
+  CoverPeekCycleBehavior,
+  CropGrowthStagesBehavior,
+  DEFENSE_ABILITIES,
+  DEFENSE_EVENTS,
+  DamageToResourceLeechBehavior,
+  DayEndUnitRecallBehavior,
+  DeathDropOwnershipBehavior,
+  DelayedShieldRegenerationBehavior,
+  DeliveredResourceConversionBehavior,
+  DriftChargeBoostBehavior,
+  DurabilityAndRepairBehavior,
+  ENCOUNTER_ABILITIES,
+  ENCOUNTER_EVENTS,
+  ENCOUNTER_INTENTS,
+  ENCOUNTER_LINKS,
+  ENVIRONMENT_ABILITIES,
+  ENVIRONMENT_MODES,
+  EncounterClearLockBehavior,
+  EnergyFundedRaceBoostBehavior,
+  EnvironmentalVaultActionBehavior,
+  EquipmentStatAggregationBehavior,
+  EscapeAttemptBehavior,
+  EscortFollowWaitBehavior,
+  ExertionAndFatigueBehavior,
+  FieldFirstStrikeBehavior,
+  FishingBiteAndHookBehavior,
+  FootprintTrailFollowingBehavior,
+  FretChordStrumBehavior,
+  FuelAmmunitionResupplyBehavior,
   GameEntity,
+  GarbageBlockConversionBehavior,
+  GolfRacketBehavior,
+  GrenadeDangerEvasionBehavior,
+  GrowthStageMobilityBehavior,
+  HammerOnPullOffChainBehavior,
+  HarvestableFruitRegrowthBehavior,
+  HoldReleaseRhythmBehavior,
+  HoverTrackSuspensionBehavior,
+  IngredientCombinationBehavior,
+  InterruptibleMagazineReloadBehavior,
+  LIFE_ABILITIES,
+  LIFE_EVENTS,
+  LandingAlignmentBailBehavior,
+  LandingSpinTransferBehavior,
+  LaneDefenseBehavior,
+  LaneTargetAcquisitionBehavior,
+  LastChanceLaneSweeperBehavior,
+  LastSeenSearchBehavior,
+  LatentAmbushActivationBehavior,
+  LayeredBreakawayArmorBehavior,
+  LeaderLossMoraleBehavior,
+  LifeSimulationBehavior,
+  LivestockDailyCareBehavior,
+  LobAndDropPlacementBehavior,
+  LocalizedWeakPointDamageBehavior,
+  MATCHING_ABILITIES,
+  MATCHING_EVENTS,
+  ManualBalanceBehavior,
+  MatchingPinballBehavior,
+  MaterialPenetratingShotBehavior,
+  MinMaxAttackRangeBehavior,
   MockBehaviorRuntime,
+  NoiseInvestigationBehavior,
+  OrderedLapCheckpointsBehavior,
+  PUZZLE_ABILITIES,
+  PedestrianPanicPropagationBehavior,
+  PerformanceFailureMeterBehavior,
+  PeriodicResourceProductionBehavior,
+  PersistentUnitLossBehavior,
+  PhraseEarnedScorePowerBehavior,
+  PinballModeObjectivesBehavior,
+  PositionWeightedRaceItemsBehavior,
+  PoweredPinballFlipperBehavior,
+  PrewoundSpinBehavior,
+  PrioritySpeedTurnOrderBehavior,
+  ProgressiveBuildingCaptureBehavior,
+  PursuitEvasionDecayBehavior,
+  RACING_ABILITIES,
+  RHYTHM_ABILITIES,
+  RHYTHM_EVENTS,
+  RPG_ABILITIES,
+  RPG_EVENTS,
+  RacingVehiclesBehavior,
+  RacketContactTimingBehavior,
+  RacketSpinShotBehavior,
+  RailGrindBalanceBehavior,
+  RallyPointAdjudicationBehavior,
+  RampLipLaunchBehavior,
+  RelationshipEventMemoryBehavior,
+  RemoteGuidedProjectileBehavior,
+  RepeatedTrickDevaluationBehavior,
+  ResourceDrainingTransformationBehavior,
+  RhythmPerformanceBehavior,
+  RhythmSceneRemixBehavior,
+  RisingStackPressureBehavior,
+  RoomFurniturePlacementBehavior,
+  SKATE_ABILITIES,
+  SPORTS_ABILITIES,
+  SQUAD_ABILITIES,
+  SQUAD_EVENTS,
   STAGE_EVENT_STRIDE,
   STAGE_INPUT_BUTTON_JUMP,
   STAGE_INPUT_BUTTON_RUN,
@@ -763,7 +2241,25 @@ export {
   STAGE_INVALID_SLOT,
   STAGE_RENDER_STRIDE,
   STAGE_SNAPSHOT_STRIDE,
+  SURVIVAL_ABILITIES,
+  SavePointCheckpointBehavior,
+  SeasonalCropEligibilityBehavior,
+  SeededLootTableBehavior,
+  ServeAndFaultSequenceBehavior,
+  ShootableProjectileInterceptionBehavior,
   Simulation,
+  SimultaneousMatchClearBehavior,
+  SingleUseObstacleVaultBehavior,
+  SkateSnowboardBehavior,
+  SlipstreamDraftingBehavior,
+  SlopeAwarePuttingBehavior,
+  SoilMoistureCycleBehavior,
+  SpatialInventoryPackingBehavior,
+  SpeciesHazardAffinityBehavior,
+  SpringPlungerLaunchBehavior,
+  SquadFlankAssignmentBehavior,
+  SquadFormationFollowBehavior,
+  SquadRtsBehavior,
   StageBodyKind,
   StageBoundaryDim,
   StageEventType,
@@ -771,24 +2267,83 @@ export {
   StageRicochetDim,
   StageRicochetReflection,
   StageTopDownPlane,
+  StaggerFinisherOpportunityBehavior,
+  StationaryAimModeBehavior,
+  StealthCityBehavior,
+  StickyGrenadeAttachmentBehavior,
+  SurfaceLatchAttackBehavior,
+  SurvivalResourcesBehavior,
+  SustainNoteTrackingBehavior,
+  SwingPowerAccuracyBehavior,
   SyncStateMachine,
+  TACTICS_ABILITIES,
+  TACTICS_EVENTS,
+  TRAVERSAL_ABILITIES,
+  TacticalBurstSelectionBehavior,
+  TacticalGridBehavior,
+  TempoMapChartPlayerBehavior,
+  TerrainDefenseModifierBehavior,
+  TerrainMovementBudgetBehavior,
+  ThreatTargetSelectionBehavior,
+  ThrownWorkerDeploymentBehavior,
+  TimedBattleActionCommandBehavior,
+  TimestampedRhythmJudgmentBehavior,
+  TrackFollowingHomingItemBehavior,
+  TrafficJunctionYieldBehavior,
+  TransportLoadUnloadBehavior,
+  TrickEarnedBoostMeterBehavior,
+  TurnBasedRpgBehavior,
+  TurnDurationStatusBehavior,
+  TypeEffectivenessMatrixBehavior,
+  TypedResistanceResolutionBehavior,
+  UnbankedTrickComboBehavior,
   VEC2_ONE,
   VEC2_ZERO,
   VEC3_ONE,
   VEC3_ZERO,
+  VehicleDamageProgressionBehavior,
+  VehicleSeatEntryExitBehavior,
+  VehicleSideAttackBehavior,
+  VisionConeAwarenessBehavior,
+  WEAPON_ABILITIES,
+  WEAPON_EVENTS,
+  WEAPON_PHASES,
+  WallRideBehavior,
+  WantedLevelEscalationBehavior,
   WasmStageRuntime,
+  WeaponAdvantageCycleBehavior,
+  WeaponHeatAndVentBehavior,
+  WeaponSystemsBehavior,
+  WeaponUpgradeTrackBehavior,
+  WhistleRecallBehavior,
+  WindDragBallFlightBehavior,
+  battleData,
+  battleOperation,
+  cityData,
   clearVelocityIntent,
+  combatAttackData,
+  combatButtons,
+  combatData,
+  combatHitData,
   createPhysicsBodyComponent,
   createSimulation,
   createTransformComponent,
   createTransformStore,
   createWasmStageRuntime,
+  defenseData,
+  defenseOperation,
   defineBehavior,
+  encounterData,
   getPosition,
+  getRequiredRuntimeBehaviors,
   getVelocity,
   isVec2Input,
   isVec3Input,
+  lifeData,
+  lifeOperation,
   makeMoveable,
+  matchingData,
+  matchingOperation,
   move,
   moveForwardXY,
   moveX,
@@ -798,18 +2353,40 @@ export {
   moveZ,
   normalizeVec2,
   normalizeVec3,
+  puzzleCommandData,
+  puzzleData,
+  racingData,
+  racingOperation,
   readBehaviorSnapshot,
   readStageRenderSlot,
   resetVelocity,
+  rhythmData,
+  rhythmOperation,
+  rpgData,
+  rpgOperation,
   setPosition,
   setPositionX,
   setPositionY,
   setPositionZ,
   setVelocityIntent,
+  skateData,
+  skateOperation,
+  sportsData,
+  sportsOperation,
+  squadData,
+  squadOperation,
+  survivalData,
+  survivalOperation,
   export_t as t,
+  tacticsData,
+  tacticsOperation,
   toThreeVector2,
   toThreeVector3,
   useBehavior,
+  weaponButtons,
+  weaponData,
+  weaponModeData,
+  weaponProjectileData,
   wrapAround3D,
   wrapAroundXY
 };