@lootlog/sdk 0.1.1 → 0.3.0

package/dist/realtime.js

@@ -1,7 +1,7 @@
-import { Result, Schema, SchemaTransformation } from "effect";
+import { Predicate, Result, Schema, SchemaTransformation } from "effect";
 import * as Schema$1 from "effect/Schema";
 import { TaggedError } from "effect/Schema";
-import { decode, encode } from "@msgpack/msgpack";
+import * as SchemaTransformation$1 from "effect/SchemaTransformation";
 //#region ../schema/src/npc-type.ts
 const NpcTypeEnum = {
 	COMMON: "COMMON",
@@ -12,6 +12,7 @@ const NpcTypeEnum = {
 	EVENT_HERO: "EVENT_HERO",
 	COLOSSUS: "COLOSSUS",
 	TITAN: "TITAN",
+	HERO_TRACKER: "HERO_TRACKER",
 	NPC: "NPC"
 };
 const NpcTypeSchema = Schema.Literals([
@@ -23,6 +24,7 @@ const NpcTypeSchema = Schema.Literals([
 	NpcTypeEnum.EVENT_HERO,
 	NpcTypeEnum.COLOSSUS,
 	NpcTypeEnum.TITAN,
+	NpcTypeEnum.HERO_TRACKER,
 	NpcTypeEnum.NPC
 ]);
 //#endregion
@@ -139,7 +141,7 @@ const NPC_PERMISSIONS = {
 Object.values(NPC_PERMISSIONS).flat();
 new Set(NPC_PERMISSIONS.loots);
 Object.values(Permission).sort();
-new Set(Object.values(NpcTypeEnum));
+Schema.is(NpcTypeSchema);
 //#endregion
 //#region ../schema/src/item-rarity.ts
 const ItemRarityEnum = {
@@ -161,21 +163,11 @@ const LootSourceEnum = {
 	DIALOG: "DIALOG",
 	FIGHT: "FIGHT"
 };
-Schema.Literals([
+const LootSourceSchema = Schema.Literals([
 	LootSourceEnum.LOOTBOX,
 	LootSourceEnum.DIALOG,
 	LootSourceEnum.FIGHT
 ]);
-const LootShareSourceEnum = {
-	NONE: "NONE",
-	ITEM_OWNER: "ITEM_OWNER",
-	CHAT_MESSAGE: "CHAT_MESSAGE"
-};
-Schema.Literals([
-	LootShareSourceEnum.NONE,
-	LootShareSourceEnum.ITEM_OWNER,
-	LootShareSourceEnum.CHAT_MESSAGE
-]);
 const ProfessionEnum = {
 	WARRIOR: "WARRIOR",
 	PALADIN: "PALADIN",
@@ -192,89 +184,56 @@ const ProfessionSchema = Schema.Literals([
 	ProfessionEnum.BLADE_DANCER,
 	ProfessionEnum.TRACKER
 ]);
-const ItemTypeEnum = {
-	ONE_HAND_WEAPON: "ONE_HAND_WEAPON",
-	TWO_HAND_WEAPON: "TWO_HAND_WEAPON",
-	ONE_AND_HALF_HAND_WEAPON: "ONE_AND_HALF_HAND_WEAPON",
-	DISTANCE_WEAPON: "DISTANCE_WEAPON",
-	HELP_WEAPON: "HELP_WEAPON",
-	WAND_WEAPON: "WAND_WEAPON",
-	ORB_WEAPON: "ORB_WEAPON",
-	ARMOR: "ARMOR",
-	HELMET: "HELMET",
-	BOOTS: "BOOTS",
-	GLOVES: "GLOVES",
-	RING: "RING",
-	NECKLACE: "NECKLACE",
-	SHIELD: "SHIELD",
-	NEUTRAL: "NEUTRAL",
-	CONSUME: "CONSUME",
-	GOLD: "GOLD",
-	KEYS: "KEYS",
-	QUEST: "QUEST",
-	RENEWABLE: "RENEWABLE",
-	ARROWS: "ARROWS",
-	TALISMAN: "TALISMAN",
-	BOOK: "BOOK",
-	BAG: "BAG",
-	BLESS: "BLESS",
-	UPGRADE: "UPGRADE",
-	RECIPE: "RECIPE",
-	COINAGE: "COINAGE",
-	QUIVER: "QUIVER",
-	OUTFITS: "OUTFITS",
-	PETS: "PETS",
-	TELEPORTS: "TELEPORTS"
-};
-Schema.Literals([
-	ItemTypeEnum.ONE_HAND_WEAPON,
-	ItemTypeEnum.TWO_HAND_WEAPON,
-	ItemTypeEnum.ONE_AND_HALF_HAND_WEAPON,
-	ItemTypeEnum.DISTANCE_WEAPON,
-	ItemTypeEnum.HELP_WEAPON,
-	ItemTypeEnum.WAND_WEAPON,
-	ItemTypeEnum.ORB_WEAPON,
-	ItemTypeEnum.ARMOR,
-	ItemTypeEnum.HELMET,
-	ItemTypeEnum.BOOTS,
-	ItemTypeEnum.GLOVES,
-	ItemTypeEnum.RING,
-	ItemTypeEnum.NECKLACE,
-	ItemTypeEnum.SHIELD,
-	ItemTypeEnum.NEUTRAL,
-	ItemTypeEnum.CONSUME,
-	ItemTypeEnum.GOLD,
-	ItemTypeEnum.KEYS,
-	ItemTypeEnum.QUEST,
-	ItemTypeEnum.RENEWABLE,
-	ItemTypeEnum.ARROWS,
-	ItemTypeEnum.TALISMAN,
-	ItemTypeEnum.BOOK,
-	ItemTypeEnum.BAG,
-	ItemTypeEnum.BLESS,
-	ItemTypeEnum.UPGRADE,
-	ItemTypeEnum.RECIPE,
-	ItemTypeEnum.COINAGE,
-	ItemTypeEnum.QUIVER,
-	ItemTypeEnum.OUTFITS,
-	ItemTypeEnum.PETS,
-	ItemTypeEnum.TELEPORTS
-]);
 //#endregion
 //#region ../schema/src/http-scalars.ts
 const FiniteNumber = Schema$1.Number.check(Schema$1.isFinite().annotate({ expected: "a finite number" }));
-const dateTimeString = (pattern) => Schema$1.String.annotate({ format: "date-time" }).check(Schema$1.isPattern(new RegExp(pattern)).annotate({ expected: `a string matching the RegExp ${pattern}` }));
-dateTimeString("^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$");
-const DateTimeWithOffsetString = dateTimeString("^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$");
-Schema$1.String.check(Schema$1.isMinLength(1).annotate({ expected: "a value with a length of at least 1" }));
+const dateTimeString = (pattern) => Schema$1.String.annotate({ format: "date-time" }).check(Schema$1.isPattern(new RegExp(pattern, "u")).annotate({ expected: `a string matching the RegExp ${pattern}` }));
+const dateTimePattern = (timeZonePattern) => `^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:${timeZonePattern}))$`;
+/** Strict ISO-8601 UTC date-time pattern shared by HTTP and domain schemas. */
+const DATE_TIME_STRING_PATTERN = dateTimePattern("Z");
+const DateTimeString = dateTimeString(DATE_TIME_STRING_PATTERN);
+dateTimeString(dateTimePattern("Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)"));
+const NonEmptyString = Schema$1.String.check(Schema$1.isMinLength(1).annotate({ expected: "a value with a length of at least 1" }));
 Schema$1.Json.annotate({ expected: "JSON value" });
-Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(-9007199254740991).annotate({ expected: "a value greater than or equal to -9007199254740991" })).check(Schema$1.isLessThanOrEqualTo(9007199254740991).annotate({ expected: "a value less than or equal to 9007199254740991" }));
-const PositiveSafeInteger = Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })).check(Schema$1.isLessThanOrEqualTo(9007199254740991).annotate({ expected: "a value less than or equal to 9007199254740991" }));
-Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })).check(Schema$1.isLessThanOrEqualTo(9007199254740991).annotate({ expected: "a value less than or equal to 9007199254740991" }));
-Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })).check(Schema$1.isLessThanOrEqualTo(500).annotate({ expected: "a value less than or equal to 500" }));
-Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })).check(Schema$1.isLessThanOrEqualTo(100).annotate({ expected: "a value less than or equal to 100" }));
+const boundedInteger = (minimum, maximum) => Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(minimum).annotate({ expected: `a value greater than or equal to ${minimum}` })).check(Schema$1.isLessThanOrEqualTo(maximum).annotate({ expected: `a value less than or equal to ${maximum}` }));
+boundedInteger(-9007199254740991, 9007199254740991);
+const PositiveSafeInteger = boundedInteger(1, 9007199254740991);
+const NonNegativeSafeInteger = boundedInteger(0, 9007199254740991);
+const LevelFilter = boundedInteger(0, 500);
+boundedInteger(1, 100);
+/** Rejects a level filter whose lower bound exceeds its upper bound. */
+const levelRangeCheck = (minKey, maxKey) => Schema$1.makeFilter((data) => {
+	const min = data[minKey];
+	const max = data[maxKey];
+	return min === void 0 || max === void 0 || min <= max ? void 0 : {
+		path: [minKey],
+		issue: `${minKey} must be <= ${maxKey}`
+	};
+});
+Schema$1.optionalKey(LevelFilter), Schema$1.optionalKey(LevelFilter), levelRangeCheck("npcLevelMin", "npcLevelMax");
+Schema$1.Array(NpcTypeSchema);
+Schema$1.Literals([
+	"24h",
+	"3d",
+	"7d",
+	"14d",
+	"30d",
+	"90d",
+	"180d",
+	"all"
+]).annotate({ default: "7d" });
+Schema$1.String.check(Schema$1.isMinLength(1), Schema$1.isMaxLength(64)).pipe(Schema$1.decode(SchemaTransformation$1.trim()), Schema$1.decode(SchemaTransformation$1.toLowerCase())).check(Schema$1.isMinLength(1).annotate({ expected: "a non-empty world" }));
+Schema$1.String.check(Schema$1.isMaxLength(100)).pipe(Schema$1.decode(SchemaTransformation$1.trim()));
+Schema$1.String.check(Schema$1.isMinLength(1), Schema$1.isMaxLength(512));
 //#endregion
 //#region ../protocol/src/loot-summary.ts
+const MapPlayersSnapshot = Schema.Array(Schema.Struct({
+	accountId: PositiveSafeInteger,
+	characterId: PositiveSafeInteger,
+	name: NonEmptyString,
+	prof: Schema.NullOr(ProfessionSchema),
+	icon: Schema.NullOr(Schema.String)
+})).check(Schema.isMinLength(1));
 const LootItemResponse = Schema.Struct({
 	id: FiniteNumber,
 	hid: Schema.String,
@@ -314,6 +273,37 @@ const LootSummary = Schema.Struct({
 	lootShare: LootShareResponse,
 	location: Schema.String
 });
+/** Same shape as the HTTP `MemberSummary`. */
+const LootMember = Schema.Struct({
+	id: Schema.Number,
+	name: Schema.String,
+	avatar: Schema.NullOr(Schema.String),
+	userId: Schema.String
+});
+const LootSubmission = Schema.Struct({
+	guildId: Schema.String,
+	memberId: Schema.Number,
+	lootId: Schema.Number,
+	member: LootMember
+});
+/** One Organization's view of a loot, as its HTTP list and detail responses encode it. */
+const LootSnapshot = Schema.Struct({
+	id: Schema.Number,
+	uniqueId: Schema.String,
+	world: Schema.String,
+	source: LootSourceSchema,
+	location: Schema.String,
+	items: Schema.Array(LootItemResponse),
+	players: Schema.Array(LootPlayerResponse),
+	mapPlayersSnapshot: Schema.NullOr(MapPlayersSnapshot),
+	npcs: Schema.Array(LootNpcResponse),
+	lootShare: LootShareResponse,
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	submissions: Schema.optionalKey(Schema.Array(LootSubmission)),
+	commentsCount: Schema.Number,
+	likes: Schema.optionalKey(Schema.Array(LootMember))
+});
 //#endregion
 //#region ../protocol/src/feed.ts
 const FeedNpc = Schema.Struct({
@@ -360,9 +350,204 @@ const UserFeedItem = Schema.Union([Schema.Struct({
 })]);
 //#endregion
 //#region ../schema/src/primitives.ts
-const NonEmptyString = Schema.NonEmptyString;
 const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-Schema.String.annotate({ format: "date-time" }).pipe(Schema.check(Schema.isPattern(/^(?:(?:\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|(?:02)-(?:0[1-9]|1\d|2[0-8])))T(?:(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?(?:Z))$/)), Schema.decodeTo(Schema.Date, SchemaTransformation.dateFromString));
+const isoDateTimePattern = new RegExp(DATE_TIME_STRING_PATTERN, "u");
+Schema.String.annotate({ format: "date-time" }).pipe(Schema.check(Schema.isPattern(isoDateTimePattern)), Schema.decodeTo(Schema.Date, SchemaTransformation.dateFromString));
+//#endregion
+//#region ../schema/src/party-ready-room.ts
+const PARTY_READY_ROOM_STATUSES = ["ACTIVE", "CANCELLED"];
+const PARTY_READY_ROOM_PARTY_PRESENCE_STATES = ["OUTSIDE", "IN_PARTY"];
+const PartyReadyRoomClanSchema = Schema.Struct({
+	id: Schema.optionalKey(Schema.Number),
+	name: Schema.optionalKey(Schema.String)
+});
+const PartyReadyRoomCharacterSchema = Schema.Struct({
+	accountId: Schema.String,
+	characterId: Schema.String,
+	icon: Schema.String,
+	lvl: Schema.Number,
+	nick: Schema.String,
+	prof: Schema.String,
+	clan: Schema.optionalKey(PartyReadyRoomClanSchema)
+});
+const PartyReadyRoomParticipantSchema = Schema.Struct({
+	participantId: Schema.String,
+	discordId: Schema.String,
+	character: PartyReadyRoomCharacterSchema,
+	partyPresence: Schema.Literals(PARTY_READY_ROOM_PARTY_PRESENCE_STATES),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const PartyGatheringNpcSchema = Schema.Struct({
+	prof: Schema.optionalKey(Schema.String),
+	icon: Schema.optionalKey(Schema.String),
+	name: Schema.String,
+	location: Schema.String,
+	lvl: Schema.Number,
+	type: Schema.String,
+	x: Schema.optionalKey(Schema.Number),
+	y: Schema.optionalKey(Schema.Number)
+});
+const PartyGatheringCharacterSchema = Schema.Struct({
+	characterId: NonEmptyString.check(Schema.isMaxLength(255)),
+	nick: Schema.String.check(Schema.isMaxLength(255)),
+	icon: Schema.String.check(Schema.isMaxLength(2048)),
+	lvl: FiniteNumber,
+	prof: Schema.String.check(Schema.isMaxLength(100))
+});
+const PartyGatheringPartyMemberSchema = Schema.Struct({
+	characterId: PartyGatheringCharacterSchema.fields.characterId,
+	nick: Schema.optionalKey(PartyGatheringCharacterSchema.fields.nick),
+	icon: Schema.optionalKey(PartyGatheringCharacterSchema.fields.icon),
+	lvl: Schema.optionalKey(PartyGatheringCharacterSchema.fields.lvl),
+	prof: Schema.optionalKey(PartyGatheringCharacterSchema.fields.prof)
+});
+const PartyGatheringPartyStateSchema = Schema.Union([Schema.Struct({ status: Schema.Literal("UNKNOWN") }), Schema.Struct({
+	status: Schema.Literal("OBSERVED"),
+	observedAt: DateTimeString,
+	members: Schema.Array(PartyGatheringPartyMemberSchema).check(Schema.isMaxLength(20))
+})]);
+const PartyGatheringVolunteerSchema = Schema.Struct({
+	...PartyGatheringCharacterSchema.fields,
+	partyPresence: Schema.Literals(PARTY_READY_ROOM_PARTY_PRESENCE_STATES)
+});
+const PartyGatheringSummarySchema = Schema.Struct({
+	notificationId: Schema.String,
+	organizerName: Schema.String,
+	organizerDiscordId: Schema.optionalKey(Schema.String),
+	organizerLvl: Schema.optionalKey(FiniteNumber),
+	organizerProf: Schema.optionalKey(Schema.String),
+	applicantCount: NonNegativeSafeInteger,
+	inPartyCount: NonNegativeSafeInteger,
+	partyMemberCount: Schema.optionalKey(NonNegativeSafeInteger),
+	revision: Schema.optionalKey(PositiveSafeInteger),
+	volunteers: Schema.optionalKey(Schema.Array(PartyGatheringVolunteerSchema)),
+	partyState: Schema.optionalKey(PartyGatheringPartyStateSchema),
+	guildIds: Schema.Array(Schema.String),
+	world: Schema.String,
+	description: Schema.optionalKey(Schema.String),
+	minLvl: Schema.optionalKey(FiniteNumber),
+	maxLvl: Schema.optionalKey(FiniteNumber),
+	npc: Schema.optionalKey(Schema.Struct({
+		...PartyGatheringNpcSchema.fields,
+		type: Schema.optionalKey(Schema.String)
+	})),
+	createdAt: DateTimeString,
+	expiresAt: DateTimeString
+});
+const PartyGatheringClientUpdateSchema = Schema.Union([Schema.Struct({
+	type: Schema.Literal("UPSERT"),
+	gathering: PartyGatheringSummarySchema
+}), Schema.Struct({
+	type: Schema.Literal("REMOVE"),
+	notificationId: Schema.String,
+	revision: PositiveSafeInteger
+})]);
+Schema.Struct({
+	guildId: Schema.String,
+	guildIds: Schema.Array(Schema.String),
+	organizerDiscordId: Schema.String,
+	npc: Schema.optionalKey(PartyGatheringNpcSchema),
+	world: Schema.String,
+	notificationId: Schema.String,
+	revision: PositiveSafeInteger,
+	update: PartyGatheringClientUpdateSchema
+});
+const PartyReadyRoomAggregateSchema = Schema.Struct({
+	schemaVersion: Schema.Literal(3),
+	npc: Schema.optionalKey(PartyGatheringNpcSchema),
+	notificationId: Schema.String,
+	organizerDiscordId: Schema.String,
+	organizerCharacter: PartyReadyRoomCharacterSchema,
+	guildIds: Schema.mutable(Schema.Array(Schema.String)),
+	world: Schema.String,
+	description: Schema.optionalKey(Schema.String),
+	minLvl: Schema.optionalKey(Schema.Number),
+	maxLvl: Schema.optionalKey(Schema.Number),
+	partyMemberCount: Schema.optionalKey(NonNegativeSafeInteger),
+	partyState: Schema.optionalKey(PartyGatheringPartyStateSchema),
+	status: Schema.Literals(PARTY_READY_ROOM_STATUSES),
+	revision: Schema.Number,
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	expiresAt: Schema.String,
+	participants: Schema.Record(Schema.String, PartyReadyRoomParticipantSchema)
+});
+const activeProjectionFields = {
+	volunteers: Schema.optionalKey(Schema.Array(PartyGatheringVolunteerSchema)),
+	...PartyReadyRoomAggregateSchema.fields,
+	participants: Schema.Record(Schema.String, Schema.mutableKey(PartyReadyRoomParticipantSchema)),
+	status: Schema.Literal("ACTIVE")
+};
+const PartyReadyRoomOrganizerProjectionSchema = Schema.Struct({
+	...activeProjectionFields,
+	viewer: Schema.Literal("ORGANIZER"),
+	ownedParticipantIds: Schema.mutable(Schema.Array(Schema.String))
+});
+const PartyReadyRoomParticipantProjectionSchema = Schema.Struct({
+	...activeProjectionFields,
+	viewer: Schema.Literal("PARTICIPANT")
+});
+const PartyReadyRoomProjectionSchema = Schema.Union([PartyReadyRoomOrganizerProjectionSchema, PartyReadyRoomParticipantProjectionSchema]);
+Schema.decodeUnknownSync(PartyReadyRoomProjectionSchema);
+const PartyReadyRoomUpsertUpdateSchema = Schema.Struct({
+	schemaVersion: Schema.Literal(3),
+	type: Schema.Literal("UPSERT"),
+	projection: PartyReadyRoomProjectionSchema
+});
+const PartyReadyRoomRemoveUpdateSchema = Schema.Struct({
+	schemaVersion: Schema.Literal(3),
+	type: Schema.Literal("REMOVE"),
+	notificationId: Schema.String,
+	revision: Schema.Number
+});
+const PartyReadyRoomClientUpdateSchema = Schema.Union([PartyReadyRoomUpsertUpdateSchema, PartyReadyRoomRemoveUpdateSchema]);
+Schema.decodeUnknownSync(PartyReadyRoomClientUpdateSchema);
+const GlobalChatMessageText = Schema.String.check(Schema.isTrimmed(), Schema.isMinLength(1), Schema.isMaxLength(128));
+/**
+* A Margonem world with its own global chat channel. Wherever a channel is
+* named, an absent world means the channel every world shares.
+*/
+const GlobalChatWorld = Schema.NonEmptyString.check(Schema.isMaxLength(64));
+/**
+* A global chat message as every Member sees it. It crosses Organization
+* boundaries, so it names the sender only by their Discord display name and
+* never carries a User, Discord, Organization or character identifier.
+*
+* `isAdmin` and the worlds are optional only for messages published before
+* channels existed; the API sets `isAdmin` on every message it stores.
+*/
+const GlobalChatMessageSchema = Schema.Struct({
+	id: Schema.NonEmptyString,
+	displayName: Schema.NonEmptyString,
+	message: GlobalChatMessageText,
+	timestamp: DateTimeString,
+	/** The channel's world; absent in the channel every world shares. */
+	world: Schema.optionalKey(GlobalChatWorld),
+	/** In the shared channel only: the world the sender wrote from. */
+	originWorld: Schema.optionalKey(GlobalChatWorld),
+	isAdmin: Schema.optionalKey(Schema.Boolean)
+});
+Schema.Union([Schema.Struct({
+	type: Schema.Literal("deleted"),
+	world: Schema.optionalKey(GlobalChatWorld),
+	id: Schema.NonEmptyString
+}), Schema.Struct({
+	type: Schema.Literal("pinned"),
+	world: Schema.optionalKey(GlobalChatWorld),
+	message: Schema.NullOr(GlobalChatMessageSchema)
+})]);
+/** Live counts the gateway sends to a channel's subscribers. */
+const GlobalChatStatsSchema = Schema.Struct({
+	world: Schema.optionalKey(GlobalChatWorld),
+	/**
+	* Unique Users with a live Game client across every Organization: on the
+	* channel's world, or on any world in the shared channel.
+	*/
+	online: NonNegativeInt,
+	/** Unique Users following this channel. */
+	listeners: NonNegativeInt
+});
 //#endregion
 //#region ../schema/src/air-tag.ts
 const AIR_TAG_RELATIONS = [
@@ -386,6 +571,11 @@ const Coordinate = Schema.Int.check(Schema.isBetween({
 	minimum: 0,
 	maximum: AIR_TAG_MAX_COORDINATE
 }));
+const Level = Schema.Int.check(Schema.isBetween({
+	minimum: 0,
+	maximum: 1e4
+}));
+const Profession = Schema.NonEmptyString.check(Schema.isMaxLength(1));
 const AirTagRelationSchema = Schema.Literals(AIR_TAG_RELATIONS);
 const AirTagClanSchema = Schema.Struct({
 	id: SafeNatural,
@@ -397,24 +587,22 @@ const AirTagObservationSchema = Schema.Struct({
 	clan: Schema.optionalKey(AirTagClanSchema),
 	relation: AirTagRelationSchema,
 	x: Coordinate,
-	y: Coordinate
+	y: Coordinate,
+	lvl: Schema.optionalKey(Level),
+	prof: Schema.optionalKey(Profession),
+	stasis: Schema.optionalKey(Schema.Boolean)
+});
+const AirTagDepartureSchema = Schema.Struct({
+	targetId: ShortString,
+	reason: Schema.Literals(["left-map", "out-of-sight"])
 });
 const AirTagObservationBatchSchema = Schema.Struct({
 	expectedMapId: Coordinate,
-	observations: Schema.Array(AirTagObservationSchema)
-});
-Schema.Struct({
-	requestId: ShortString,
-	enabled: Schema.Boolean,
-	expectedMapId: Schema.optionalKey(Coordinate)
+	observations: Schema.Array(AirTagObservationSchema),
+	departures: Schema.optionalKey(Schema.Array(AirTagDepartureSchema))
 });
 const AirTagTargetSchema = Schema.Struct({
-	targetId: ShortString,
-	nickname: ShortString,
-	clan: Schema.optionalKey(AirTagClanSchema),
-	relation: AirTagRelationSchema,
-	x: Coordinate,
-	y: Coordinate,
+	...AirTagObservationSchema.fields,
 	observedAt: SafeNatural,
 	enemyObservedAt: Schema.optionalKey(SafeNatural),
 	clanEnemyObservedAt: Schema.optionalKey(SafeNatural)
@@ -429,23 +617,220 @@ const AirTagScopeIdentityFields = {
 };
 const AirTagScopeSnapshotSchema = Schema.Struct({
 	...AirTagScopeIdentityFields,
-	targets: Schema.Array(AirTagTargetSchema)
+	targets: Schema.Array(AirTagTargetSchema),
+	serverTime: Schema.optionalKey(SafeNatural)
 });
 const AirTagUpdateEventSchema = Schema.Struct({
 	...AirTagScopeIdentityFields,
 	target: AirTagTargetSchema
 });
-Schema.is(AirTagRelationSchema);
+const AirTagScopeUpdateEventSchema = Schema.Struct({
+	...AirTagScopeIdentityFields,
+	targets: Schema.Array(AirTagTargetSchema),
+	removedTargetIds: Schema.Array(ShortString)
+});
+const AirTagMapThreatEventSchema = Schema.Struct({
+	guildId: GuildId,
+	world: ShortString,
+	mapId: Coordinate,
+	mapName: Schema.NonEmptyString.check(Schema.isMaxLength(128)),
+	revision: SafeNatural,
+	enemies: Schema.Array(Schema.Struct({
+		targetId: AirTagObservationSchema.fields.targetId,
+		nickname: AirTagObservationSchema.fields.nickname,
+		clan: AirTagObservationSchema.fields.clan,
+		lvl: AirTagObservationSchema.fields.lvl,
+		prof: AirTagObservationSchema.fields.prof,
+		stasis: AirTagObservationSchema.fields.stasis,
+		ageMs: SafeNatural
+	}))
+});
 Schema.is(AirTagObservationSchema);
-Schema.is(AirTagTargetSchema);
+Schema.is(AirTagRelationSchema);
 Schema.is(AirTagScopeSnapshotSchema);
 Schema.is(AirTagUpdateEventSchema);
+Schema.is(AirTagScopeUpdateEventSchema);
+Schema.is(AirTagDepartureSchema);
+//#endregion
+//#region ../schema/src/battle-ping.ts
+/** Pings placed on an enemy warrior. `attack` is the team's shared target. */
+const BATTLE_ENEMY_PING_TYPES = [
+	"attack",
+	"caution",
+	"spare"
+];
+/** Requests placed on an allied warrior (or on the sender's own warrior). */
+const BATTLE_REQUEST_PING_TYPES = [
+	"attack-speed-aura",
+	"atmo",
+	"cleanse",
+	"emanating-arrow",
+	"fury",
+	"heal",
+	"healing-wave",
+	"need-heal",
+	"poison",
+	"protection-aura",
+	"rime",
+	"stigma",
+	"taunt"
+];
+/**
+* Calls to the whole battle team, sent from the sender's own warrior. Only
+* sockets that negotiated `lootlog.battle-ping.team.v1` send or receive them.
+*/
+const BATTLE_TEAM_PING_TYPES = ["quick-fight"];
+const BATTLE_PING_TYPES = [
+	...BATTLE_ENEMY_PING_TYPES,
+	...BATTLE_REQUEST_PING_TYPES,
+	...BATTLE_TEAM_PING_TYPES
+];
+/** A Margonem party holds at most ten characters, so nine other recipients. */
+const MAX_BATTLE_PING_RECIPIENTS = 9;
+/** Margonem battle warrior ids: positive for characters, negative for NPCs. */
+const MAX_BATTLE_WARRIOR_ID = 2147483647;
+const BattlePingTypeSchema = Schema.Literals(BATTLE_PING_TYPES);
+const BattleWarriorIdSchema = Schema.Int.check(Schema.isBetween({
+	minimum: -2147483647,
+	maximum: MAX_BATTLE_WARRIOR_ID
+}), Schema.makeFilter((id) => id !== 0 || "warrior id must not be 0"));
+const CharacterIdSchema$1 = Schema.String.check(Schema.isPattern(/^[1-9]\d{0,9}$/u));
+Schema.is(BattlePingTypeSchema);
+Schema.is(Schema.Literals(BATTLE_ENEMY_PING_TYPES));
+Schema.is(Schema.Literals(BATTLE_TEAM_PING_TYPES));
+const BattlePingSendPayloadSchema = Schema.Struct({
+	expectedMapId: NonNegativeInt,
+	type: BattlePingTypeSchema,
+	warriorId: BattleWarriorIdSchema,
+	recipientCharacterIds: Schema.Array(CharacterIdSchema$1).check(Schema.isMinLength(1), Schema.isMaxLength(MAX_BATTLE_PING_RECIPIENTS))
+});
+const BattlePingEventSchema = Schema.Struct({
+	pingId: Schema.NonEmptyString,
+	world: Schema.NonEmptyString,
+	mapId: NonNegativeInt,
+	type: BattlePingTypeSchema,
+	warriorId: BattleWarriorIdSchema,
+	sender: Schema.Struct({
+		characterId: Schema.NonEmptyString,
+		name: Schema.NonEmptyString
+	}),
+	createdAt: NonNegativeInt
+});
+//#endregion
+//#region ../schema/src/loot-split.ts
+/**
+* A participant's choice for one item of a group loot split, as Margonem's
+* `loot.states` reports it: 0 "nie chcę", 1 "chcę", 2 "bardzo chcę".
+*/
+const LOOT_SPLIT_CHOICES = [
+	0,
+	1,
+	2
+];
+/** A Margonem party holds at most ten characters, so nine other recipients. */
+const MAX_LOOT_SPLIT_RECIPIENTS = 9;
+/** Bounds a frame; one group loot holds far fewer items. */
+const MAX_LOOT_SPLIT_ITEMS = 64;
+const ITEM_ID_PATTERN = /^[1-9]\d{0,17}$/u;
+const ItemIdSchema = Schema.String.check(Schema.isPattern(ITEM_ID_PATTERN));
+const CharacterIdSchema = Schema.String.check(Schema.isPattern(/^[1-9]\d{0,9}$/u));
+const RecipientCharacterIdsSchema = Schema.Array(CharacterIdSchema).check(Schema.isMinLength(1), Schema.isMaxLength(MAX_LOOT_SPLIT_RECIPIENTS));
+const SenderSchema = Schema.Struct({
+	characterId: Schema.NonEmptyString,
+	name: Schema.NonEmptyString
+});
+const LootSplitChoicesSchema = Schema.Record(Schema.String, Schema.Literals(LOOT_SPLIT_CHOICES)).check(Schema.makeFilter((choices) => {
+	const ids = Object.keys(choices);
+	return ids.length <= MAX_LOOT_SPLIT_ITEMS && ids.every((id) => ITEM_ID_PATTERN.test(id)) || "choices must map at most 64 item ids";
+}));
+const LootSplitSendPayloadSchema = Schema.Struct({
+	splitId: ItemIdSchema,
+	choices: LootSplitChoicesSchema,
+	accepted: Schema.Boolean,
+	recipientCharacterIds: RecipientCharacterIdsSchema
+});
+const LootSplitEventSchema = Schema.Struct({
+	splitId: ItemIdSchema,
+	world: Schema.NonEmptyString,
+	sender: SenderSchema,
+	choices: LootSplitChoicesSchema,
+	accepted: Schema.Boolean,
+	sentAt: NonNegativeInt
+});
+const LootSplitAutoAcceptPayloadSchema = Schema.Struct({ recipientCharacterIds: RecipientCharacterIdsSchema });
+const LootSplitAutoAcceptedEventSchema = Schema.Struct({
+	world: Schema.NonEmptyString,
+	sender: SenderSchema,
+	sentAt: NonNegativeInt
+});
+const LootSplitAckSchema = Schema.Union([Schema.Struct({ status: Schema.Literal("accepted") }), Schema.Struct({
+	status: Schema.Literal("rejected"),
+	code: Schema.Literals([
+		"forbidden",
+		"invalid-context",
+		"invalid-payload",
+		"rate-limited",
+		"temporarily-unavailable"
+	]),
+	retryAfterMs: Schema.optionalKey(NonNegativeInt)
+})]);
+/** The fields organization NPC visibility needs, keyed by the NPC's runtime id. */
+const NpcPresenceNpcSchema = Schema.Struct({
+	id: NonNegativeInt,
+	lvl: NonNegativeInt,
+	wt: NonNegativeInt,
+	prof: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(8))),
+	type: Schema.optionalKey(NonNegativeInt)
+});
+/** Every NPC a character currently sees on its map; each report replaces the previous one. */
+const NpcPresenceReportSchema = Schema.Struct({
+	world: Schema.NonEmptyString.check(Schema.isMaxLength(64)),
+	organizationIds: Schema.Array(Schema.NonEmptyString).check(Schema.isMaxLength(20)),
+	npcs: Schema.Array(NpcPresenceNpcSchema).check(Schema.isMaxLength(50))
+});
+/** Sent only when an NPC gains its first reporter or loses its last one. */
+const NpcPresenceEventSchema = Schema.Struct({
+	organizationId: Schema.NonEmptyString,
+	world: Schema.NonEmptyString,
+	/** Orders the updates of one Organization and world across gateway replicas. */
+	revision: NonNegativeInt,
+	npc: NpcPresenceNpcSchema,
+	standing: Schema.Boolean,
+	/** Gateway time the NPC was first reported. */
+	since: NonNegativeInt
+});
+const NpcPresenceSnapshotSchema = Schema.Struct({
+	revision: NonNegativeInt,
+	npcs: Schema.Array(Schema.Struct({
+		npc: NpcPresenceNpcSchema,
+		since: NonNegativeInt
+	}))
+});
+const NpcPresenceRejectCode = Schema.Literals([
+	"forbidden",
+	"invalid-context",
+	"invalid-payload",
+	"rate-limited",
+	"temporarily-unavailable"
+]);
+const NpcPresenceReportAckSchema = Schema.Union([Schema.Struct({ status: Schema.Literal("accepted") }), Schema.Struct({
+	status: Schema.Literal("rejected"),
+	code: NpcPresenceRejectCode,
+	retryAfterMs: Schema.optional(NonNegativeInt)
+})]);
+//#endregion
+//#region ../schema/src/map-ping.ts
 const MapPingTypeSchema = Schema.Literals([
 	"attention",
 	"enemy",
 	"regroup",
 	"avoid"
 ]);
+/** Margonem NPC and character ids are positive 32-bit integers. */
+const MapPingCharacterIdSchema = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 2147483647
+}));
 const MapPingRejectCodeSchema = Schema.Literals([
 	"forbidden",
 	"invalid-context",
@@ -454,11 +839,16 @@ const MapPingRejectCodeSchema = Schema.Literals([
 	"temporarily-unavailable"
 ]);
 Schema.is(MapPingTypeSchema);
-const MapPingSendPayloadSchema = Schema.Struct({
-	expectedMapId: NonNegativeInt,
+const mapPingFields = {
 	type: MapPingTypeSchema,
 	x: NonNegativeInt,
-	y: NonNegativeInt
+	y: NonNegativeInt,
+	npcId: Schema.optionalKey(MapPingCharacterIdSchema),
+	playerId: Schema.optionalKey(MapPingCharacterIdSchema)
+};
+const MapPingSendPayloadSchema = Schema.Struct({
+	expectedMapId: NonNegativeInt,
+	...mapPingFields
 });
 const MapPingAckSchema = Schema.Union([Schema.Struct({
 	status: Schema.Literal("accepted"),
@@ -472,9 +862,7 @@ const MapPingEventSchema = Schema.Struct({
 	pingId: Schema.NonEmptyString,
 	world: Schema.NonEmptyString,
 	mapId: NonNegativeInt,
-	type: MapPingTypeSchema,
-	x: NonNegativeInt,
-	y: NonNegativeInt,
+	...mapPingFields,
 	sender: Schema.Struct({
 		characterId: Schema.NonEmptyString,
 		name: Schema.NonEmptyString
@@ -482,302 +870,24 @@ const MapPingEventSchema = Schema.Struct({
 	createdAt: NonNegativeInt
 });
 //#endregion
-//#region ../schema/src/discord.ts
-const discordPermissionFields = {
-	hasRequiredPermissions: Schema.Boolean,
-	requiredPermissions: Schema.Array(Schema.String),
-	grantedPermissions: Schema.Array(Schema.String),
-	missingPermissions: Schema.Array(Schema.String)
-};
-const DiscordGuildSyncStatus = Schema.Literals([
-	"SYNCED",
-	"SYNCING",
-	"FAILED",
-	"STALE",
-	"NOT_FOUND"
-]);
-//#endregion
-//#region ../protocol/src/rabbit/topology.ts
-const RabbitExchange = {
-	DEFAULT: "default",
-	DEAD_LETTER: "dlx",
-	RETRY: "retry"
-};
-const RabbitExchangeName = Schema.Literals([
-	RabbitExchange.DEFAULT,
-	RabbitExchange.DEAD_LETTER,
-	RabbitExchange.RETRY
-]);
-const RabbitRoutingKey = {
-	USERS_ONLINE_CHECKPOINT_V1: "users.online.checkpoint.v1",
-	USERS_ONLINE_CHECKPOINT_V1_RETRY: "users.online.checkpoint.v1.retry",
-	USERS_ONLINE_CHECKPOINT_V1_DLQ: "users.online.checkpoint.v1.dlq",
-	ACTIVITY_LOG_CREATE: "activity.log.create",
-	ACTIVITY_LOG_CREATE_DLQ: "activity.log.create.dlq",
-	ACTIVITY_LOG_CREATE_RETRY: "activity.log.create.retry",
-	DISCORD_GUILD_CHANNEL_DELETED: "discord.guild.channel.deleted",
-	DISCORD_GUILD_CHANNEL_UPSERTED: "discord.guild.channel.upserted",
-	DISCORD_GUILD_CHANNELS_SYNC_FAILED: "discord.guild.channels.sync.failed",
-	DISCORD_GUILD_CHANNELS_SYNCED: "discord.guild.channels.synced",
-	DISCORD_GUILD_SYNC_STATE_UPDATED: "discord.guild.sync-state.updated",
-	EVENT_HERO_KILLED: "event.hero.killed",
-	EVENT_MAP_STATUS_UPDATE: "event.map-status.update",
-	EVENT_RANKING_UPDATE: "event.ranking.update",
-	EVENT_RESPAWN_WINDOW_CLOSED: "event.respawn-window.closed",
-	EVENT_RESPAWN_WINDOW_OPENED: "event.respawn-window.opened",
-	GUILDS_CLEAR_MESSAGES: "guilds.clear.messages",
-	GUILDS_CREATE: "guilds.create",
-	GUILDS_CREATE_DLQ: "guilds.create.dlq",
-	GUILDS_CREATE_RETRY: "guilds.create.retry",
-	GUILDS_CREATE_ROLE: "guilds.create.role",
-	GUILDS_CREATE_ROLE_DLQ: "guilds.create.role.dlq",
-	GUILDS_CREATE_ROLE_RETRY: "guilds.create.role.retry",
-	GUILDS_DELETE: "guilds.delete",
-	GUILDS_DELETE_DLQ: "guilds.delete.dlq",
-	GUILDS_DELETE_MESSAGE: "guilds.delete.message",
-	GUILDS_DELETE_RETRY: "guilds.delete.retry",
-	GUILDS_DELETE_ROLE: "guilds.delete.role",
-	GUILDS_DELETE_ROLE_DLQ: "guilds.delete.role.dlq",
-	GUILDS_DELETE_ROLE_RETRY: "guilds.delete.role.retry",
-	GUILDS_INITIALIZE: "guilds.initialize",
-	GUILDS_INITIALIZE_BOT: "guilds.initialize-bot",
-	GUILDS_INITIALIZE_DLQ: "guilds.initialize.dlq",
-	GUILDS_INITIALIZE_RETRY: "guilds.initialize.retry",
-	GUILDS_KILLS_ACCEPTED_V1: "guilds.kills.accepted.v1",
-	GUILDS_KILLS_ACCEPTED_V1_RETRY: "guilds.kills.accepted.v1.retry",
-	GUILDS_KILLS_ACCEPTED_V1_DLQ: "guilds.kills.accepted.v1.dlq",
-	GUILDS_LOOTS_CREATE: "guilds.loots.create",
-	GUILDS_LOOTS_CREATE_DLQ: "guilds.loots.create.dlq",
-	GUILDS_LOOTS_CREATE_RETRY: "guilds.loots.create.retry",
-	GUILDS_LOOTS_DELETE: "guilds.loots.delete",
-	GUILDS_LOOTS_SHARE_UPDATE: "guilds.loots.share.update",
-	GUILDS_LOOTS_SHARE_UPDATE_DLQ: "guilds.loots.share.update.dlq",
-	GUILDS_LOOTS_SHARE_UPDATE_RETRY: "guilds.loots.share.update.retry",
-	GUILDS_LOOTS_UPDATE: "guilds.loots.update",
-	GUILDS_MEMBERS_ADD: "guilds.members.add",
-	GUILDS_MEMBERS_ADD_DLQ: "guilds.members.add.dlq",
-	GUILDS_MEMBERS_ADD_RETRY: "guilds.members.add.retry",
-	GUILDS_MEMBERS_ADD_ROLE: "guilds.members.add.role",
-	GUILDS_MEMBERS_ADD_ROLE_DLQ: "guilds.members.add.role.dlq",
-	GUILDS_MEMBERS_ADD_ROLE_RETRY: "guilds.members.add.role.retry",
-	GUILDS_MEMBERS_REFRESH_JOB_UPDATE: "guilds.members.refresh.job.update",
-	GUILDS_MEMBERS_REMOVE: "guilds.members.remove",
-	GUILDS_MEMBERS_REMOVE_DLQ: "guilds.members.remove.dlq",
-	GUILDS_MEMBERS_REMOVE_RETRY: "guilds.members.remove.retry",
-	GUILDS_MEMBERS_REMOVE_ROLE: "guilds.members.remove.role",
-	GUILDS_MEMBERS_REMOVE_ROLE_DLQ: "guilds.members.remove.role.dlq",
-	GUILDS_MEMBERS_REMOVE_ROLE_RETRY: "guilds.members.remove.role.retry",
-	GUILDS_MEMBERS_UPDATE: "guilds.members.update",
-	GUILDS_MEMBERS_UPDATE_DLQ: "guilds.members.update.dlq",
-	GUILDS_MEMBERS_UPDATE_RETRY: "guilds.members.update.retry",
-	GUILDS_NOTIFICATIONS_SEND: "guilds.notifications.send",
-	GUILDS_NOTIFICATIONS_SEND_DLQ: "guilds.notifications.send.dlq",
-	GUILDS_NOTIFICATIONS_SEND_RETRY: "guilds.notifications.send.retry",
-	GUILDS_NOTIFICATIONS_VOLUNTEER: "guilds.notifications.volunteer",
-	GUILDS_NOTIFICATIONS_VOLUNTEER_DLQ: "guilds.notifications.volunteer.dlq",
-	GUILDS_NOTIFICATIONS_VOLUNTEER_RETRY: "guilds.notifications.volunteer.retry",
-	GUILDS_PARTY_GATHERING: "guilds.party-gathering",
-	GUILDS_PARTY_GATHERING_CANCEL: "guilds.party-gathering.cancel",
-	GUILDS_PARTY_GATHERING_DLQ: "guilds.party-gathering.dlq",
-	GUILDS_PARTY_GATHERING_RETRY: "guilds.party-gathering.retry",
-	GUILDS_RESERVATIONS_CHANGED_V2: "guilds.reservations.v2.changed",
-	GUILDS_RESERVATIONS_CHANGED_V2_DLQ: "guilds.reservations.v2.changed.dlq",
-	GUILDS_RESERVATIONS_CHANGED_V2_RETRY: "guilds.reservations.v2.changed.retry",
-	GUILDS_RESERVATIONS_CREATE: "guilds.reservations.create",
-	GUILDS_RESERVATIONS_CREATE_DLQ: "guilds.reservations.create.dlq",
-	GUILDS_RESERVATIONS_CREATE_RETRY: "guilds.reservations.create.retry",
-	GUILDS_RESERVATIONS_DELETE: "guilds.reservations.delete",
-	GUILDS_RESERVATIONS_DELETE_DLQ: "guilds.reservations.delete.dlq",
-	GUILDS_RESERVATIONS_DELETE_RETRY: "guilds.reservations.delete.retry",
-	GUILDS_SEND_MESSAGE: "guilds.send.message",
-	GUILDS_SEND_MESSAGE_DLQ: "guilds.send.message.dlq",
-	GUILDS_SEND_MESSAGE_RETRY: "guilds.send.message.retry",
-	GUILDS_SYNC: "guilds.sync",
-	GUILDS_SYNC_TRIGGER: "guilds.sync.trigger",
-	GUILDS_TIMERS_DELETE: "guilds.timers.delete",
-	GUILDS_TIMERS_DELETE_DLQ: "guilds.timers.delete.dlq",
-	GUILDS_TIMERS_DELETE_RETRY: "guilds.timers.delete.retry",
-	GUILDS_TIMERS_UPDATE: "guilds.timers.update",
-	GUILDS_TIMERS_UPDATE_DLQ: "guilds.timers.update.dlq",
-	GUILDS_TIMERS_UPDATE_RETRY: "guilds.timers.update.retry",
-	GUILDS_UPDATE: "guilds.update",
-	GUILDS_UPDATE_DLQ: "guilds.update.dlq",
-	GUILDS_UPDATE_MESSAGE: "guilds.update.message",
-	GUILDS_UPDATE_RETRY: "guilds.update.retry",
-	GUILDS_UPDATE_ROLE: "guilds.update.role",
-	GUILDS_UPDATE_ROLE_DLQ: "guilds.update.role.dlq",
-	GUILDS_UPDATE_ROLE_RETRY: "guilds.update.role.retry",
-	NOTIFICATIONS_DELIVERY_RESULT: "notifications.delivery.result",
-	NOTIFICATIONS_DISCORD_SEND: "notifications.discord.send",
-	NOTIFICATIONS_LOOT_CREATED: "notifications.loot.created",
-	NOTIFICATIONS_TIMER_DELETED: "notifications.timer.deleted",
-	NOTIFICATIONS_TIMER_UPDATED: "notifications.timer.updated",
-	GAME_CHARACTER_OFFLINE: "game.character.offline",
-	PRESENCE_CHECK_REQUEST: "presence.check.request",
-	PRESENCE_COVERAGE_CHECK: "presence.coverage.check",
-	SEARCH_ITEMS_INDEX: "search.items.index",
-	SEARCH_NPCS_INDEX: "search.npcs.index",
-	SEARCH_PLAYERS_INDEX: "search.players.index",
-	USERS_PARTY_READY_ROOM_UPDATED: "users.party-ready-room.updated",
-	USERS_PARTY_READY_ROOM_UPDATED_DLQ: "users.party-ready-room.updated.dlq",
-	USERS_PARTY_READY_ROOM_UPDATED_RETRY: "users.party-ready-room.updated.retry"
-};
-const RabbitRoutingKeyName = Schema.Literals(Object.values(RabbitRoutingKey));
-Schema.Struct({
-	name: RabbitExchangeName,
-	type: Schema.Literal("topic"),
-	durable: Schema.Boolean
-});
-Schema.Struct({
-	name: Schema.String,
-	exchange: RabbitExchangeName,
-	routingKey: RabbitRoutingKeyName,
-	durable: Schema.Boolean,
-	messageTtl: Schema.optional(Schema.Int),
-	singleActiveConsumer: Schema.optional(Schema.Boolean),
-	deadLetterExchange: Schema.optional(RabbitExchangeName),
-	deadLetterRoutingKey: Schema.optional(RabbitRoutingKeyName)
-});
-RabbitExchange.DEFAULT, RabbitExchange.RETRY, RabbitExchange.DEAD_LETTER;
-Schema.Struct({
-	userId: NonEmptyString,
-	discordId: NonEmptyString,
-	world: NonEmptyString,
-	characterId: NonEmptyString,
-	organizationIds: Schema.Array(NonEmptyString),
-	disconnectedAt: NonNegativeInt
-});
-const NullableString = Schema.NullOr(Schema.String);
-const NullableNumber = Schema.NullOr(Schema.Number);
-const GuildRole = Schema.Struct({
-	id: NonEmptyString,
-	name: NonEmptyString,
-	color: Schema.Number,
-	admin: Schema.Boolean,
-	position: Schema.Number
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	name: NonEmptyString,
-	icon: NullableString,
-	ownerId: NonEmptyString,
-	roles: Schema.Array(GuildRole)
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	name: NonEmptyString,
-	icon: NullableString,
-	ownerId: NonEmptyString
-});
-Schema.Struct({ guildId: NonEmptyString });
-Schema.Struct({
-	guildId: NonEmptyString,
-	...GuildRole.fields
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	id: NonEmptyString
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	discordId: NonEmptyString,
-	userId: NonEmptyString
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	mapName: NonEmptyString
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	mapName: NonEmptyString,
-	discordId: NonEmptyString,
-	hasPlayer: Schema.Boolean,
-	isAfk: Schema.optional(Schema.Boolean)
-});
-const DiscordGuildChannel = Schema.Struct({
-	guildId: NonEmptyString,
-	channelId: NonEmptyString,
-	name: NonEmptyString,
-	channelType: NonEmptyString,
-	parentId: NullableString,
-	position: Schema.Number,
-	active: Schema.Boolean,
-	canView: Schema.Boolean,
-	canSend: Schema.Boolean,
-	...discordPermissionFields,
-	lastSyncedAt: NonEmptyString
-});
-const DiscordGuildSyncState = Schema.Struct({
-	guildId: NonEmptyString,
-	status: DiscordGuildSyncStatus,
-	...discordPermissionFields,
-	channelCount: NonNegativeInt,
-	selectableChannelCount: NonNegativeInt,
-	lastAttemptAt: NullableString,
-	lastSuccessAt: NullableString,
-	lastError: NullableString,
-	updatedAt: NonEmptyString
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	channels: Schema.Array(DiscordGuildChannel),
-	syncState: DiscordGuildSyncState
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	channel: DiscordGuildChannel,
-	syncState: DiscordGuildSyncState
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	status: DiscordGuildSyncStatus,
-	lastAttemptAt: NonEmptyString,
-	lastError: NonEmptyString
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	syncState: DiscordGuildSyncState
-});
-Schema.Union([Schema.Struct({ guildId: NonEmptyString }), Schema.Struct({ organizationId: NonEmptyString })]);
-Schema.Struct({
-	recipientDiscordId: NonEmptyString,
-	eligibleGuildIds: Schema.Array(NonEmptyString),
-	update: Schema.Unknown
-});
-Schema.Struct({
-	notificationId: NonEmptyString,
-	targetDiscordId: NonEmptyString,
-	volunteerDiscordId: NonEmptyString,
-	world: NonEmptyString,
-	character: Schema.Unknown
-});
+//#region ../protocol/src/loot-events.ts
 const GuildLootEventNpc = Schema.Struct({
-	lvl: Schema.optional(NullableNumber),
-	prof: Schema.optional(NullableString),
+	lvl: Schema.optional(Schema.NullOr(Schema.Number)),
+	prof: Schema.optional(Schema.NullOr(Schema.String)),
 	type: Schema.optional(Schema.NullOr(Schema.Union([Schema.Number, Schema.String]))),
 	wt: Schema.optional(Schema.NullOr(Schema.Union([Schema.Number, Schema.String])))
 });
-Schema.Struct({
-	sourceNpcs: Schema.optional(Schema.Array(Schema.Struct({
-		level: NonNegativeInt,
-		type: NpcTypeSchema
-	}))),
-	feedEntry: Schema.optional(UserFeedItem),
-	version: Schema.Literal(1),
-	guildId: NonEmptyString,
-	world: NonEmptyString,
-	npc: Schema.Struct({
-		type: NpcTypeSchema,
-		lvl: NonNegativeInt
-	})
-});
 const GuildLootCreatedEventV2 = Schema.Struct({
 	feedEntry: Schema.optional(UserFeedItem),
 	version: Schema.Literal(2),
-	guildId: NonEmptyString,
+	guildId: Schema.NonEmptyString,
 	lootId: NonNegativeInt,
 	npcs: Schema.Array(GuildLootEventNpc)
 });
+const GuildLootCreatedMessageV2 = Schema.Struct({
+	...GuildLootCreatedEventV2.fields,
+	loot: Schema.optional(LootSnapshot)
+});
 const GuildLootShareUpdatedEventV2 = Schema.Struct({
 	...GuildLootCreatedEventV2.fields,
 	lootShare: Schema.Record(Schema.String, Schema.Array(Schema.String))
@@ -790,105 +900,29 @@ const ReservationChangedEventV2 = Schema.Struct({
 		"deleted",
 		"sharing-changed"
 	]),
-	sourceGuildId: NonEmptyString,
-	audienceGuildIds: Schema.Array(NonEmptyString),
+	sourceGuildId: Schema.NonEmptyString,
+	audienceGuildIds: Schema.Array(Schema.NonEmptyString),
 	reservationId: Schema.NullOr(NonNegativeInt),
 	spotId: Schema.NullOr(Schema.String)
 });
-const EventScope = Schema.Struct({
-	guildId: NonEmptyString,
-	eventId: NonEmptyString
-});
-Schema.Struct({
-	...EventScope.fields,
-	heroNpcLvl: Schema.optional(Schema.NullOr(NonNegativeInt)),
-	mapId: NonEmptyString,
-	reason: Schema.optional(Schema.String)
-});
-Schema.Struct({
-	...EventScope.fields,
-	heroNpcLvl: Schema.optional(Schema.NullOr(NonNegativeInt)),
-	heroId: Schema.optional(NonEmptyString)
-});
-Schema.Struct({
-	...EventScope.fields,
-	heroNpcLvl: Schema.optional(Schema.NullOr(NonNegativeInt)),
-	heroId: NonEmptyString
-});
-Schema.Struct({
-	userId: NonEmptyString,
-	guildId: Schema.optional(NonEmptyString),
-	action: NonEmptyString,
-	entityType: Schema.optional(NonEmptyString),
-	entityId: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
-	metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	world: NonEmptyString,
-	npcId: NonNegativeInt,
-	timerKey: NonEmptyString,
-	minSpawnTime: NonEmptyString,
-	maxSpawnTime: NonEmptyString,
-	npc: Schema.optional(Schema.NullOr(Schema.Struct({ name: Schema.optional(Schema.String) })))
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	world: NonEmptyString,
-	timerKey: NonEmptyString,
-	npcId: Schema.optional(NonNegativeInt)
-});
-Schema.Struct({
-	version: Schema.Literal(2),
-	lootId: NonNegativeInt,
-	world: NonEmptyString,
-	guildIds: Schema.Array(NonEmptyString),
-	itemIds: Schema.Array(NonNegativeInt),
-	itemNames: Schema.Array(Schema.String),
-	npcs: Schema.Array(Schema.Struct({
-		type: NullableString,
-		lvl: NullableNumber
-	}))
-});
-Schema.Struct({
-	notificationJobId: NonEmptyString,
-	success: Schema.Boolean,
-	retryable: Schema.Boolean,
-	providerMessageId: Schema.optional(NullableString),
-	errorCode: Schema.optional(NullableString),
-	errorMessage: Schema.optional(NullableString),
-	deliveredAt: NonEmptyString
-});
-Schema.Struct({
-	guildId: NonEmptyString,
-	channelId: NonEmptyString,
-	syncState: DiscordGuildSyncState
-});
-/** Cumulative confirmed game presence. A gap starts a new segment; retries never extend it. */
-const UserOnlineCheckpointV1 = Schema.Struct({
-	version: Schema.Literal(1),
-	type: Schema.Literal("checkpoint"),
-	userId: NonEmptyString,
-	sessionId: NonEmptyString,
-	segmentId: NonEmptyString,
-	world: Schema.optional(NonEmptyString),
-	startedAt: DateTimeWithOffsetString,
-	endedAt: DateTimeWithOffsetString,
-	observedAt: DateTimeWithOffsetString
-}).check(Schema.makeFilter((event) => Date.parse(event.startedAt) <= Date.parse(event.endedAt) && Date.parse(event.endedAt) <= Date.parse(event.observedAt), { expected: "ordered confirmed interval timestamps" }));
-/** Published only after the durable publisher has drained its pending checkpoints. */
-const UserOnlineHealthV1 = Schema.Struct({
-	version: Schema.Literal(1),
-	type: Schema.Literal("collector"),
-	observedAt: DateTimeWithOffsetString,
-	status: Schema.Literals(["healthy", "degraded"])
-});
-Schema.Union([UserOnlineCheckpointV1, UserOnlineHealthV1]);
-RabbitRoutingKey.GAME_CHARACTER_OFFLINE, RabbitRoutingKey.GUILDS_KILLS_ACCEPTED_V1, RabbitRoutingKey.USERS_ONLINE_CHECKPOINT_V1, RabbitRoutingKey.ACTIVITY_LOG_CREATE, RabbitRoutingKey.DISCORD_GUILD_CHANNEL_DELETED, RabbitRoutingKey.DISCORD_GUILD_CHANNEL_UPSERTED, RabbitRoutingKey.DISCORD_GUILD_CHANNELS_SYNC_FAILED, RabbitRoutingKey.DISCORD_GUILD_CHANNELS_SYNCED, RabbitRoutingKey.DISCORD_GUILD_SYNC_STATE_UPDATED, RabbitRoutingKey.EVENT_HERO_KILLED, RabbitRoutingKey.EVENT_MAP_STATUS_UPDATE, RabbitRoutingKey.EVENT_RANKING_UPDATE, RabbitRoutingKey.EVENT_RESPAWN_WINDOW_CLOSED, RabbitRoutingKey.EVENT_RESPAWN_WINDOW_OPENED, RabbitRoutingKey.GUILDS_LOOTS_CREATE, RabbitRoutingKey.GUILDS_LOOTS_SHARE_UPDATE, RabbitRoutingKey.GUILDS_CREATE, RabbitRoutingKey.GUILDS_DELETE, RabbitRoutingKey.GUILDS_UPDATE, RabbitRoutingKey.GUILDS_CREATE_ROLE, RabbitRoutingKey.GUILDS_DELETE_ROLE, RabbitRoutingKey.GUILDS_UPDATE_ROLE, RabbitRoutingKey.GUILDS_MEMBERS_ADD, RabbitRoutingKey.GUILDS_MEMBERS_ADD_ROLE, RabbitRoutingKey.GUILDS_MEMBERS_REMOVE, RabbitRoutingKey.GUILDS_MEMBERS_REMOVE_ROLE, RabbitRoutingKey.GUILDS_MEMBERS_UPDATE, RabbitRoutingKey.GUILDS_TIMERS_UPDATE, RabbitRoutingKey.GUILDS_TIMERS_DELETE, RabbitRoutingKey.GUILDS_RESERVATIONS_CREATE, RabbitRoutingKey.GUILDS_RESERVATIONS_DELETE, RabbitRoutingKey.GUILDS_SEND_MESSAGE, RabbitRoutingKey.GUILDS_UPDATE_MESSAGE, RabbitRoutingKey.GUILDS_DELETE_MESSAGE, RabbitRoutingKey.GUILDS_CLEAR_MESSAGES, RabbitRoutingKey.GUILDS_NOTIFICATIONS_SEND, RabbitRoutingKey.GUILDS_NOTIFICATIONS_VOLUNTEER, RabbitRoutingKey.GUILDS_PARTY_GATHERING, RabbitRoutingKey.GUILDS_PARTY_GATHERING_CANCEL, RabbitRoutingKey.GUILDS_MEMBERS_REFRESH_JOB_UPDATE, RabbitRoutingKey.GUILDS_RESERVATIONS_CHANGED_V2, RabbitRoutingKey.NOTIFICATIONS_DELIVERY_RESULT, RabbitRoutingKey.NOTIFICATIONS_LOOT_CREATED, RabbitRoutingKey.NOTIFICATIONS_TIMER_DELETED, RabbitRoutingKey.NOTIFICATIONS_TIMER_UPDATED, RabbitRoutingKey.PRESENCE_CHECK_REQUEST, RabbitRoutingKey.PRESENCE_COVERAGE_CHECK, RabbitRoutingKey.USERS_PARTY_READY_ROOM_UPDATED;
-const REALTIME_SUBPROTOCOL = "lootlog.realtime.v1";
+const { feedEntry: _feedEntry, ...lootCreatedFields } = GuildLootCreatedMessageV2.fields;
+const LootSnapshotEvent = Schema.Struct(lootCreatedFields);
 const REALTIME_JSON_SUBPROTOCOL = "lootlog.realtime.json.v1";
+const REALTIME_CLIENT_CLOSE_CODES = {
+	heartbeatTimeout: 4001,
+	heartbeatRejected: 4002,
+	heartbeatUnavailable: 4003,
+	malformedFrame: 4007,
+	sessionJoinFailed: 4008
+};
+const REALTIME_SERVER_CLOSE_CODES = {
+	restarting: 1012,
+	tryAgainLater: 1013
+};
+const REALTIME_SERVER_CLOSE_RECONNECT_WINDOW_MS = 3e4;
 const PRESENCE_HEARTBEAT_INTERVAL_MS = 25e3;
-const RequestId = NonEmptyString;
+const PRESENCE_EXPIRY_MS = 6e4;
+const RequestId = Schema.NonEmptyString;
 const Revision = NonNegativeInt;
 const Timestamp = NonNegativeInt;
 const RealtimeLogicalTopic = Schema.Literals([
@@ -903,13 +937,15 @@ const RealtimeLogicalTopic = Schema.Literals([
 	"event.coordination",
 	"map.air-tags",
 	"map.pings",
-	"party.ready-room"
+	"party.ready-room",
+	"global.chat",
+	"global.chat.world"
 ]);
 const SubscriptionScope = Schema.Struct({
 	topic: RealtimeLogicalTopic,
-	organizationId: Schema.optional(NonEmptyString),
-	eventId: Schema.optional(NonEmptyString),
-	world: Schema.optional(NonEmptyString),
+	organizationId: Schema.optional(Schema.NonEmptyString),
+	eventId: Schema.optional(Schema.NonEmptyString),
+	world: Schema.optional(Schema.NonEmptyString),
 	mapId: Schema.optional(NonNegativeInt)
 });
 const PresencePlatform = Schema.Literals(["game", "web-app"]);
@@ -921,26 +957,26 @@ const PresenceClan = Schema.Struct({
 	rank: Schema.optional(Schema.Int)
 });
 const PresenceCharacter = Schema.Struct({
-	world: NonEmptyString,
-	name: NonEmptyString,
+	world: Schema.NonEmptyString,
+	name: Schema.NonEmptyString,
 	lvl: NonNegativeInt,
 	icon: Schema.String,
-	characterId: NonEmptyString,
-	accountId: NonEmptyString,
+	characterId: Schema.NonEmptyString,
+	accountId: Schema.NonEmptyString,
 	prof: Schema.String,
 	clan: Schema.optional(PresenceClan)
 });
 const PrecisePresenceLocation = Schema.Struct({
 	mapId: Schema.optional(NonNegativeInt),
-	map: NonEmptyString,
+	map: Schema.NonEmptyString,
 	x: Schema.optional(NonNegativeInt),
 	y: Schema.optional(NonNegativeInt)
 });
 const BasicPresence = Schema.Struct({
-	userId: NonEmptyString,
-	discordId: Schema.optional(NonEmptyString),
-	sessionId: NonEmptyString,
-	organizationIds: Schema.Array(NonEmptyString),
+	userId: Schema.NonEmptyString,
+	discordId: Schema.optional(Schema.NonEmptyString),
+	sessionId: Schema.NonEmptyString,
+	organizationIds: Schema.Array(Schema.NonEmptyString),
 	platform: PresencePlatform,
 	status: PresenceStatus,
 	confidence: PresenceConfidence,
@@ -953,29 +989,29 @@ const PresenceWithLocation = Schema.Struct({
 	location: PrecisePresenceLocation
 });
 const PublishedPresence = Schema.Struct({
-	organizationIds: Schema.Array(NonEmptyString),
+	organizationIds: Schema.Array(Schema.NonEmptyString),
 	isAfk: Schema.optional(Schema.Boolean),
 	character: Schema.optional(PresenceCharacter),
 	location: Schema.optional(PrecisePresenceLocation),
 	clientObservedAt: Schema.optional(Timestamp)
 });
 const PresenceSnapshot = Schema.Struct({
-	organizationId: NonEmptyString,
-	world: Schema.optional(NonEmptyString),
+	organizationId: Schema.NonEmptyString,
+	world: Schema.optional(Schema.NonEmptyString),
 	revision: Revision,
 	presences: Schema.Array(Schema.Union([PresenceWithLocation, BasicPresence]))
 });
 const PresenceDelta = Schema.Struct({
-	organizationId: NonEmptyString,
+	organizationId: Schema.NonEmptyString,
 	revision: Revision,
 	changes: Schema.Array(Schema.Union([Schema.Struct({
 		action: Schema.Literal("upsert"),
 		presence: Schema.Union([PresenceWithLocation, BasicPresence])
 	}), Schema.Struct({
 		action: Schema.Literal("remove"),
-		userId: NonEmptyString,
-		discordId: Schema.optional(NonEmptyString),
-		sessionId: NonEmptyString
+		userId: Schema.NonEmptyString,
+		discordId: Schema.optional(Schema.NonEmptyString),
+		sessionId: Schema.NonEmptyString
 	})]))
 });
 const command = (type, data) => Schema.Struct({
@@ -985,25 +1021,40 @@ const command = (type, data) => Schema.Struct({
 	data
 });
 const SessionJoinCommand = command("session.join", Schema.Struct({
-	world: Schema.optional(NonEmptyString),
+	world: Schema.optional(Schema.NonEmptyString),
 	character: Schema.optional(PresenceCharacter),
 	margonemAccountProof: Schema.optional(Schema.Unknown)
 }));
-const HeartbeatCommand = command("presence.heartbeat", Schema.Struct({ sessionId: NonEmptyString }));
+const HeartbeatCommand = command("presence.heartbeat", Schema.Struct({ sessionId: Schema.NonEmptyString }));
 const PresencePublishCommand = command("presence.publish", PublishedPresence);
+const PingCommand = command("connection.ping", Schema.Struct({}));
 const PresenceFetchCommand = command("presence.fetch", Schema.Struct({
-	organizationId: NonEmptyString,
-	world: Schema.optional(NonEmptyString)
+	organizationId: Schema.NonEmptyString,
+	world: Schema.optional(Schema.NonEmptyString),
+	delivery: Schema.optional(Schema.Literal("response"))
 }));
 const SubscribeCommand = command("subscription.subscribe", SubscriptionScope);
 const UnsubscribeCommand = command("subscription.unsubscribe", SubscriptionScope);
 const MapPingCommand = command("map-ping.send", MapPingSendPayloadSchema);
+const BattlePingCommand = command("battle-ping.send", BattlePingSendPayloadSchema);
+const LootSplitCommand = command("loot-split.send", LootSplitSendPayloadSchema);
+const LootSplitAutoAcceptCommand = command("loot-split.auto-accept", LootSplitAutoAcceptPayloadSchema);
 const AirTagSubscriptionCommand = command("air-tag.subscription", Schema.Struct({
 	requestId: RequestId,
 	enabled: Schema.Boolean,
 	expectedMapId: Schema.optional(NonNegativeInt)
 }));
 const AirTagObservationCommand = command("air-tag.observation", AirTagObservationBatchSchema);
+const AirTagMapThreatsFetchCommand = command("air-tag.map-threats.fetch", Schema.Struct({
+	organizationId: Schema.NonEmptyString,
+	world: Schema.NonEmptyString
+}));
+const AirTagMapThreatsFetchResponse = Schema.Struct({ threats: Schema.Array(AirTagMapThreatEventSchema) });
+const NpcPresenceReportCommand = command("npc-presence.report", NpcPresenceReportSchema);
+const NpcPresenceFetchCommand = command("npc-presence.fetch", Schema.Struct({
+	organizationId: Schema.NonEmptyString,
+	world: Schema.NonEmptyString
+}));
 const AirTagRejectCode = Schema.Literals([
 	"forbidden",
 	"invalid-context",
@@ -1032,17 +1083,24 @@ const AirTagObservationAck = Schema.Union([Schema.Struct({
 const ClientCommand = Schema.Union([
 	SessionJoinCommand,
 	HeartbeatCommand,
+	PingCommand,
 	PresencePublishCommand,
 	PresenceFetchCommand,
 	SubscribeCommand,
 	UnsubscribeCommand,
 	MapPingCommand,
+	BattlePingCommand,
+	LootSplitCommand,
+	LootSplitAutoAcceptCommand,
 	AirTagSubscriptionCommand,
-	AirTagObservationCommand
+	AirTagObservationCommand,
+	AirTagMapThreatsFetchCommand,
+	NpcPresenceReportCommand,
+	NpcPresenceFetchCommand
 ]);
 const RealtimeError = Schema.Struct({
-	code: NonEmptyString,
-	message: NonEmptyString,
+	code: Schema.NonEmptyString,
+	message: Schema.NonEmptyString,
 	retryable: Schema.Boolean,
 	retryAfterMs: Schema.optional(NonNegativeInt),
 	details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
@@ -1065,19 +1123,21 @@ const serverEvent = (type, data) => Schema.Struct({
 	data
 });
 const OrganizationEvent = Schema.Struct({
-	organizationId: NonEmptyString,
+	organizationId: Schema.NonEmptyString,
 	payload: Schema.Unknown
 });
 const ServerEvent = Schema.Union([
+	serverEvent("session.hello", Schema.Struct({ connectionId: Schema.NonEmptyString })),
 	serverEvent("session.joined", Schema.Struct({
-		connectionId: NonEmptyString,
-		organizationIds: Schema.Array(NonEmptyString),
+		connectionId: Schema.NonEmptyString,
+		organizationIds: Schema.Array(Schema.NonEmptyString),
 		subscriptionScopes: Schema.Array(SubscriptionScope),
-		accessPolicy: Schema.optional(AccessPolicySnapshot)
+		accessPolicy: Schema.optional(AccessPolicySnapshot),
+		capabilities: Schema.optional(Schema.Array(Schema.NonEmptyString))
 	})),
 	serverEvent("permissions.updated", Schema.Struct({
 		changes: Schema.optional(Schema.Array(AccessPolicyChange)),
-		organizationIds: Schema.Array(NonEmptyString),
+		organizationIds: Schema.Array(Schema.NonEmptyString),
 		subscriptionScopes: Schema.Array(SubscriptionScope),
 		accessPolicy: Schema.optional(AccessPolicySnapshot)
 	})),
@@ -1087,12 +1147,24 @@ const ServerEvent = Schema.Union([
 	serverEvent("chat.updated", OrganizationEvent),
 	serverEvent("chat.deleted", OrganizationEvent),
 	serverEvent("chat.cleared", OrganizationEvent),
+	serverEvent("global-chat.created", GlobalChatMessageSchema),
+	serverEvent("global-chat.deleted", Schema.Struct({
+		world: Schema.optionalKey(GlobalChatWorld),
+		id: Schema.NonEmptyString
+	})),
+	serverEvent("global-chat.pinned", Schema.Struct({
+		world: Schema.optionalKey(GlobalChatWorld),
+		message: Schema.NullOr(GlobalChatMessageSchema)
+	})),
+	serverEvent("global-chat.stats", GlobalChatStatsSchema),
 	serverEvent("feed.entry", UserFeedItem),
-	serverEvent("kills.changed", Schema.Struct({ guildId: NonEmptyString })),
+	serverEvent("kills.changed", Schema.Struct({ guildId: Schema.NonEmptyString })),
 	serverEvent("loot.created", GuildLootCreatedEventV2),
 	serverEvent("loot.share-updated", GuildLootShareUpdatedEventV2),
+	serverEvent("loot.snapshot", LootSnapshotEvent),
 	serverEvent("timer.created", OrganizationEvent),
 	serverEvent("timer.deleted", OrganizationEvent),
+	serverEvent("hero-sighting.updated", OrganizationEvent),
 	serverEvent("reservation.created", OrganizationEvent),
 	serverEvent("reservation.deleted", OrganizationEvent),
 	serverEvent("reservation.changed", ReservationChangedEventV2),
@@ -1100,19 +1172,29 @@ const ServerEvent = Schema.Union([
 	serverEvent("member-refresh.updated", OrganizationEvent),
 	serverEvent("party-gathering.updated", OrganizationEvent),
 	serverEvent("party-gathering.cancelled", OrganizationEvent),
+	serverEvent("party-gathering.state-updated", Schema.Struct({
+		organizationId: Schema.NonEmptyString,
+		payload: PartyGatheringClientUpdateSchema
+	})),
 	serverEvent("party-ready-room.updated", OrganizationEvent),
 	serverEvent("map-ping.received", MapPingEventSchema),
+	serverEvent("battle-ping.received", BattlePingEventSchema),
+	serverEvent("loot-split.received", LootSplitEventSchema),
+	serverEvent("loot-split.auto-accepted", LootSplitAutoAcceptedEventSchema),
 	serverEvent("air-tag.updated", AirTagUpdateEventSchema),
+	serverEvent("air-tag.scope-updated", AirTagScopeUpdateEventSchema),
+	serverEvent("air-tag.map-threat-updated", AirTagMapThreatEventSchema),
+	serverEvent("npc-presence.updated", NpcPresenceEventSchema),
 	serverEvent("event.map-status-updated", OrganizationEvent),
 	serverEvent("event.hero-killed", OrganizationEvent),
 	serverEvent("event.ranking-updated", OrganizationEvent),
 	serverEvent("event.respawn-window-opened", OrganizationEvent),
 	serverEvent("event.respawn-window-closed", OrganizationEvent),
 	serverEvent("notification.volunteer", Schema.Struct({
-		notificationId: NonEmptyString,
+		notificationId: Schema.NonEmptyString,
 		volunteer: Schema.StructWithRest(Schema.Struct({
-			discordId: NonEmptyString,
-			world: NonEmptyString
+			discordId: Schema.NonEmptyString,
+			world: Schema.NonEmptyString
 		}), [Schema.Record(Schema.String, Schema.Unknown)])
 	}))
 ]);
@@ -1122,9 +1204,8 @@ const RealtimeFrame = Schema.Union([
 	ServerEvent
 ]);
 Schema.decodeUnknownSync(ClientCommand);
-Schema.decodeUnknownSync(Response);
 Schema.decodeUnknownSync(ServerEvent);
-const decodeRealtimeFrame = Schema.decodeUnknownSync(RealtimeFrame);
+Schema.decodeUnknownSync(RealtimeFrame);
 const serverEventTypes = new Set(ServerEvent.members.map((member) => member.fields.type.literal));
 const isServerEventFrame = (frame) => "type" in frame && serverEventTypes.has(frame.type);
 //#endregion
@@ -1140,7 +1221,7 @@ const tryEncodeFrame = (frame) => Result.try({
 		const validated = Schema.encodeUnknownSync(RealtimeFrame)(frame);
 		return {
 			frame: validated,
-			bytes: encode(validated, { ignoreUndefined: true })
+			text: JSON.stringify(validated)
 		};
 	},
 	catch: (error) => new RealtimeCodecError({
@@ -1149,26 +1230,62 @@ const tryEncodeFrame = (frame) => Result.try({
 		cause: error
 	})
 });
-const tryEncodeRealtimeFrame = (frame) => Result.map(tryEncodeFrame(frame), ({ bytes }) => bytes);
+const tryEncodeRealtimeFrame = (frame) => Result.map(tryEncodeFrame(frame), ({ text }) => text);
 const encodeRealtimeFrame = (frame) => Result.getOrThrow(tryEncodeRealtimeFrame(frame));
-const tryDecodeRealtimeFrame = (bytes) => Result.try({
-	try: () => {
-		const input = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
-		return Schema.decodeUnknownSync(RealtimeFrame)(decode(input));
-	},
+const rejectProtoKey = (key, value) => {
+	if (key === "__proto__") throw new Error("The key __proto__ is not allowed");
+	return value;
+};
+/**
+* Whether a JSON text cannot have a `__proto__` key. A key can spell it only
+* literally or through a `\u` escape.
+*/
+const isWithoutProtoKey = (text) => !text.includes("__proto__") && !text.includes("\\u");
+/**
+* JSON-parse a realtime text, rejecting any `__proto__` key. The reviver makes
+* parsing several times slower, so it runs only when the text may need it.
+*/
+const parseRealtimeJson = (text) => isWithoutProtoKey(text) ? JSON.parse(text) : JSON.parse(text, rejectProtoKey);
+const tryDecode = (input) => Result.try({
+	try: () => Schema.decodeUnknownSync(RealtimeFrame)(input()),
 	catch: (error) => new RealtimeCodecError({
 		operation: "decode",
 		message: getErrorMessage(error),
 		cause: error
 	})
 });
+const tryDecodeRealtimeFrame = (text) => tryDecode(() => parseRealtimeJson(text));
+const decodeRealtimeFrame = (text) => Result.getOrThrow(tryDecodeRealtimeFrame(text));
 Schema.decodeUnknownSync(PresenceSnapshot);
 Schema.is(MapPingAckSchema);
+Schema.is(LootSplitAckSchema);
 Schema.is(AirTagSubscriptionAck);
 Schema.is(AirTagObservationAck);
+Schema.is(AirTagMapThreatsFetchResponse);
+Schema.is(NpcPresenceReportAckSchema);
+Schema.is(NpcPresenceSnapshotSchema);
+const hasRealtimeCapabilities = Schema.is(Schema.Struct({ capabilities: Schema.Array(Schema.NonEmptyString) }));
 Schema.is(Schema.Struct({ presences: Schema.optional(PresenceSnapshot.fields.presences) }));
 //#endregion
+//#region ../client/src/realtime/notify-listeners.ts
+const reportListenerError = ({ source, error }) => {
+	try {
+		console.warn(`[Realtime] ${source} listener failed:`, error);
+	} catch {}
+};
+const notifyListeners = (listeners, notify, source) => {
+	for (const listener of listeners) try {
+		notify(listener);
+	} catch (error) {
+		reportListenerError({
+			source,
+			error
+		});
+	}
+};
+//#endregion
 //#region ../client/src/realtime/realtime-client.ts
+var RealtimeRequestTimeout = class extends Error {};
 var RealtimeRequestError = class extends Error {
 	code;
 	retryable;
@@ -1193,6 +1310,7 @@ const normalizeUrl = (baseUrl, path) => {
 };
 const nativeWebSocketFactory = (url, protocols) => new WebSocket(url, protocols);
 const WEBSOCKET_OPEN = 1;
+const MIN_HEARTBEAT_RETRY_BUDGET_MS = 2e3;
 const scopeKey = (scope) => JSON.stringify([
 	scope.topic,
 	scope.organizationId ?? null,
@@ -1200,12 +1318,7 @@ const scopeKey = (scope) => JSON.stringify([
 	scope.world ?? null,
 	scope.mapId ?? null
 ]);
-const toBytes = async (data) => {
-	if (data instanceof Uint8Array) return data;
-	if (data instanceof ArrayBuffer) return new Uint8Array(data);
-	if (data instanceof Blob) return new Uint8Array(await data.arrayBuffer());
-	throw new Error("Gateway returned a non-binary realtime frame");
-};
+const SERVER_CLOSE_CODES = new Set(Object.values(REALTIME_SERVER_CLOSE_CODES));
 const getPresenceSessionId = (data) => {
 	if (!data || typeof data !== "object" || !("sessionId" in data)) return null;
 	return typeof data.sessionId === "string" ? data.sessionId : null;
@@ -1218,30 +1331,34 @@ var RealtimeClient = class {
 	reconnectMaxDelayMs;
 	random;
 	webSocketFactory;
-	frameEncoding;
 	eventListeners = /* @__PURE__ */ new Set();
 	stateListeners = /* @__PURE__ */ new Set();
+	heartbeatLatencyMs = null;
+	heartbeatLatencyListeners = /* @__PURE__ */ new Set();
 	pending = /* @__PURE__ */ new Map();
 	subscriptions = /* @__PURE__ */ new Map();
 	socket = null;
 	stateValue = "disconnected";
 	joinData = null;
+	joinAttempt = null;
 	reconnectAttempt = 0;
+	reconnectNotBeforeMs = 0;
 	reconnectTimeout = null;
 	heartbeatTimeout = null;
 	presenceSessionId = null;
+	presenceRefreshedAt = 0;
+	pingSupported = false;
+	latencyProbeInFlight = false;
 	manuallyClosed = false;
-	messageChain = Promise.resolve();
 	rejoinHandler = null;
 	constructor(options) {
 		this.url = normalizeUrl(options.url, options.path ?? "/ws");
-		this.protocols = options.protocols ? [...options.protocols] : void 0;
+		this.protocols = [.../* @__PURE__ */ new Set([REALTIME_JSON_SUBPROTOCOL, ...options.protocols ?? []])];
 		this.requestTimeoutMs = options.requestTimeoutMs ?? 2e4;
 		this.reconnectBaseDelayMs = options.reconnectBaseDelayMs ?? 1e3;
 		this.reconnectMaxDelayMs = options.reconnectMaxDelayMs ?? 3e4;
 		this.random = options.random ?? Math.random;
 		this.webSocketFactory = options.webSocketFactory ?? nativeWebSocketFactory;
-		this.frameEncoding = options.frameEncoding ?? "messagepack";
 	}
 	get state() {
 		return this.stateValue;
@@ -1259,6 +1376,7 @@ var RealtimeClient = class {
 		this.manuallyClosed = true;
 		this.clearReconnect();
 		this.clearHeartbeat();
+		this.pingSupported = false;
 		this.rejectPending(/* @__PURE__ */ new Error("Realtime client disconnected"));
 		const activeSocket = this.socket;
 		this.socket = null;
@@ -1274,6 +1392,30 @@ var RealtimeClient = class {
 		listener(this.stateValue);
 		return () => this.stateListeners.delete(listener);
 	}
+	subscribeHeartbeatLatency(listener) {
+		this.heartbeatLatencyListeners.add(listener);
+		listener(this.heartbeatLatencyMs);
+		return () => this.heartbeatLatencyListeners.delete(listener);
+	}
+	/**
+	* Measures the round trip now instead of at the next heartbeat. A gateway
+	* that does not advertise `connection.ping` keeps the heartbeat measurement.
+	*/
+	probeLatency() {
+		if (!this.pingSupported || this.stateValue !== "ready" || this.latencyProbeInFlight) return;
+		const socket = this.socket;
+		const startedAt = performance.now();
+		this.latencyProbeInFlight = true;
+		this.request("connection.ping", {}).then(() => {
+			if (this.socket === socket) this.setHeartbeatLatency(Math.round(performance.now() - startedAt));
+		}).catch(() => {}).finally(() => {
+			this.latencyProbeInFlight = false;
+		});
+	}
+	setHeartbeatLatency(latencyMs) {
+		this.heartbeatLatencyMs = latencyMs;
+		notifyListeners(this.heartbeatLatencyListeners, (listener) => listener(latencyMs), "heartbeat latency");
+	}
 	setReconnectHandler(handler) {
 		this.rejoinHandler = handler;
 	}
@@ -1292,22 +1434,26 @@ var RealtimeClient = class {
 		return this.request("subscription.unsubscribe", scope);
 	}
 	request(type, data) {
+		return this.requestWithTimeout(type, data, this.requestTimeoutMs);
+	}
+	requestWithTimeout(type, data, timeoutMs) {
 		const activeSocket = this.socket;
 		if (!activeSocket || activeSocket.readyState !== WEBSOCKET_OPEN) return Promise.reject(/* @__PURE__ */ new Error("Realtime connection is not open"));
 		const requestId = crypto.randomUUID();
 		return new Promise((resolve, reject) => {
 			const timeout = setTimeout(() => {
 				this.pending.delete(requestId);
-				reject(/* @__PURE__ */ new Error(`Realtime request timed out: ${type}`));
-			}, this.requestTimeoutMs);
+				reject(new RealtimeRequestTimeout(`Realtime request timed out: ${type}`));
+			}, timeoutMs);
 			this.pending.set(requestId, {
 				type,
+				startedAt: performance.now(),
 				resolve,
 				reject,
 				timeout
 			});
 			try {
-				activeSocket.send(this.encodeFrame({
+				activeSocket.send(encodeRealtimeFrame({
 					v: 1,
 					type,
 					requestId,
@@ -1323,7 +1469,7 @@ var RealtimeClient = class {
 	send(type, data) {
 		const activeSocket = this.socket;
 		if (!activeSocket || activeSocket.readyState !== WEBSOCKET_OPEN) return;
-		activeSocket.send(this.encodeFrame({
+		activeSocket.send(encodeRealtimeFrame({
 			v: 1,
 			type,
 			data
@@ -1333,44 +1479,79 @@ var RealtimeClient = class {
 		this.setState(state);
 		if (this.manuallyClosed) return;
 		const socket = this.webSocketFactory(this.url, this.protocols);
-		socket.binaryType = "arraybuffer";
 		this.socket = socket;
 		socket.addEventListener("open", () => {
 			if (this.socket !== socket) return;
 			this.setState("connected");
-			if (this.joinData) (this.rejoinHandler ?? (() => this.performJoin().then(() => void 0)))().catch(() => socket.close(4008, "session rejoin failed"));
+			if (this.joinData && (this.rejoinHandler || this.stateValue === "connected")) (this.rejoinHandler ?? (() => this.performJoin().then(() => void 0)))().catch(() => socket.close(REALTIME_CLIENT_CLOSE_CODES.sessionJoinFailed, "session rejoin failed"));
 		});
 		socket.addEventListener("message", (event) => {
-			this.messageChain = this.messageChain.then(() => this.handleMessage(event.data)).catch(() => socket.close(4007, "malformed realtime frame"));
-		});
-		socket.addEventListener("error", () => {
-			if (this.socket === socket) socket.close();
+			try {
+				this.handleMessage(event.data, socket);
+			} catch {
+				socket.close(REALTIME_CLIENT_CLOSE_CODES.malformedFrame, "malformed realtime frame");
+			}
 		});
-		socket.addEventListener("close", () => {
+		socket.addEventListener("close", (event) => {
 			if (this.socket !== socket) return;
 			this.socket = null;
+			if (event.code !== void 0 && SERVER_CLOSE_CODES.has(event.code)) this.reconnectNotBeforeMs = Math.round(this.random() * REALTIME_SERVER_CLOSE_RECONNECT_WINDOW_MS);
 			this.clearHeartbeat();
+			this.pingSupported = false;
 			this.rejectPending(/* @__PURE__ */ new Error("Realtime connection closed"));
 			this.setState("disconnected");
 			if (!this.manuallyClosed) this.scheduleReconnect();
 		});
 	}
-	async performJoin() {
-		if (!this.joinData || !this.connected) return void 0;
+	performJoin(data = this.joinData) {
+		const socket = this.socket;
+		if (!data || !socket || !this.connected) return Promise.resolve(void 0);
+		const key = JSON.stringify(data);
+		const pending = this.joinAttempt;
+		if (pending?.socket === socket) {
+			if (pending.key === key) return pending.promise;
+			return pending.promise.then(() => {
+				if (this.socket !== socket || !this.connected) throw new Error("Realtime connection changed before queued join");
+				return this.performJoin(data);
+			});
+		}
+		const promise = this.restoreSession(socket, this.request("session.join", data));
+		this.joinAttempt = {
+			socket,
+			key,
+			promise
+		};
 		this.setState("joining");
+		return promise;
+	}
+	async restoreSession(socket, joined) {
 		try {
-			const result = await this.request("session.join", this.joinData);
+			const result = await joined;
+			if (this.socket !== socket) return result;
+			this.pingSupported = hasRealtimeCapabilities(result) && result.capabilities.includes("connection.ping");
 			await Promise.all([...this.subscriptions.values()].map((scope) => this.request("subscription.subscribe", scope)));
+			if (this.socket !== socket) return result;
 			this.reconnectAttempt = 0;
 			this.setState("ready");
 			return result;
 		} catch (error) {
-			if (this.connected) this.socket?.close(4008, "session join failed");
+			if (this.socket === socket) {
+				if (error instanceof RealtimeRequestError && !error.retryable) {
+					this.manuallyClosed = true;
+					this.clearReconnect();
+				}
+				if (error instanceof RealtimeRequestError && error.retryable) this.reconnectNotBeforeMs = error.retryAfterMs ?? 0;
+				socket.close(REALTIME_CLIENT_CLOSE_CODES.sessionJoinFailed, "session join failed");
+			}
 			throw error;
+		} finally {
+			if (this.joinAttempt?.socket === socket) this.joinAttempt = null;
 		}
 	}
-	async handleMessage(data) {
-		const frame = await this.decodeFrame(data);
+	handleMessage(data, socket) {
+		if (this.socket !== socket) return;
+		if (!Predicate.isString(data)) throw new Error("Gateway returned a non-text realtime frame");
+		const frame = decodeRealtimeFrame(data);
 		if ("status" in frame) {
 			const pending = this.pending.get(frame.requestId);
 			if (!pending) return;
@@ -1379,6 +1560,7 @@ var RealtimeClient = class {
 			if (frame.status === "success") {
 				if (pending.type === "presence.publish") {
 					this.presenceSessionId = getPresenceSessionId(frame.data);
+					this.presenceRefreshedAt = pending.startedAt;
 					this.scheduleHeartbeat();
 				}
 				pending.resolve(frame.data);
@@ -1386,35 +1568,64 @@ var RealtimeClient = class {
 			return;
 		}
 		if (!isServerEventFrame(frame)) return;
-		for (const listener of this.eventListeners) listener(frame);
-	}
-	encodeFrame(frame) {
-		return this.frameEncoding === "json" ? JSON.stringify(frame) : encodeRealtimeFrame(frame);
-	}
-	async decodeFrame(data) {
-		if (this.frameEncoding === "json") {
-			if (typeof data !== "string") throw new Error("Gateway returned a non-text realtime frame");
-			return decodeRealtimeFrame(JSON.parse(data));
-		}
-		const decoded = tryDecodeRealtimeFrame(await toBytes(data));
-		if (Result.isFailure(decoded)) throw decoded.failure;
-		return decoded.success;
+		notifyListeners(this.eventListeners, (listener) => listener(frame), `server event ${frame.type}`);
 	}
 	scheduleReconnect() {
 		this.reconnectAttempt += 1;
 		const exponential = Math.min(this.reconnectMaxDelayMs, this.reconnectBaseDelayMs * 2 ** (this.reconnectAttempt - 1));
-		const jittered = Math.round(exponential * (.5 + this.random()));
+		const jittered = Math.max(Math.round(exponential * (.5 + this.random())), this.reconnectNotBeforeMs);
+		this.reconnectNotBeforeMs = 0;
 		this.setState("reconnecting");
 		this.reconnectTimeout = setTimeout(() => this.open("reconnecting"), jittered);
 	}
-	scheduleHeartbeat() {
+	scheduleHeartbeat(delayMs = PRESENCE_HEARTBEAT_INTERVAL_MS, retryAttempt = 0) {
 		this.clearHeartbeat();
-		if (!this.presenceSessionId || !this.connected) return;
+		if (!this.presenceSessionId || !this.connected) {
+			this.setHeartbeatLatency(null);
+			return;
+		}
 		this.heartbeatTimeout = setTimeout(() => {
 			const sessionId = this.presenceSessionId;
 			if (!sessionId) return;
-			this.request("presence.heartbeat", { sessionId }).then(() => this.scheduleHeartbeat()).catch(() => this.socket?.close());
-		}, PRESENCE_HEARTBEAT_INTERVAL_MS);
+			const startedAt = performance.now();
+			const socket = this.socket;
+			const refreshedAt = this.presenceRefreshedAt;
+			const expiry = refreshedAt + PRESENCE_EXPIRY_MS;
+			const remaining = expiry - startedAt;
+			if (remaining <= 0 || retryAttempt > 0 && remaining < MIN_HEARTBEAT_RETRY_BUDGET_MS) {
+				this.setHeartbeatLatency(null);
+				socket?.close(REALTIME_CLIENT_CLOSE_CODES.heartbeatUnavailable, "heartbeat unavailable");
+				return;
+			}
+			const isStaleHeartbeat = () => this.socket !== socket || this.presenceSessionId !== sessionId || this.presenceRefreshedAt !== refreshedAt;
+			this.requestWithTimeout("presence.heartbeat", { sessionId }, Math.min(this.requestTimeoutMs, remaining)).then(() => {
+				if (isStaleHeartbeat()) return;
+				this.presenceRefreshedAt = startedAt;
+				this.setHeartbeatLatency(Math.round(performance.now() - startedAt));
+				this.scheduleHeartbeat();
+			}).catch((error) => {
+				if (isStaleHeartbeat()) return;
+				this.setHeartbeatLatency(null);
+				if (error instanceof RealtimeRequestError && error.retryable) {
+					const retryDelay = Math.max(Math.round(Math.min(5e3, 1e3 * 2 ** retryAttempt) * (.5 + this.random())), error.retryAfterMs ?? 0);
+					if (expiry - performance.now() - retryDelay >= MIN_HEARTBEAT_RETRY_BUDGET_MS) {
+						this.scheduleHeartbeat(retryDelay, retryAttempt + 1);
+						return;
+					}
+					socket?.close(REALTIME_CLIENT_CLOSE_CODES.heartbeatUnavailable, "heartbeat unavailable");
+					return;
+				}
+				if (error instanceof RealtimeRequestTimeout) {
+					socket?.close(REALTIME_CLIENT_CLOSE_CODES.heartbeatTimeout, "heartbeat timeout");
+					return;
+				}
+				if (error instanceof RealtimeRequestError) {
+					socket?.close(REALTIME_CLIENT_CLOSE_CODES.heartbeatRejected, "heartbeat rejected");
+					return;
+				}
+				socket?.close();
+			});
+		}, delayMs);
 	}
 	rejectPending(error) {
 		for (const pending of this.pending.values()) {
@@ -1426,7 +1637,8 @@ var RealtimeClient = class {
 	setState(state) {
 		if (this.stateValue === state) return;
 		this.stateValue = state;
-		for (const listener of this.stateListeners) listener(state);
+		if (state === "disconnected") this.setHeartbeatLatency(null);
+		notifyListeners(this.stateListeners, (listener) => listener(state), `connection state ${state}`);
 	}
 	clearReconnect() {
 		if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
@@ -1438,6 +1650,6 @@ var RealtimeClient = class {
 	}
 };
 //#endregion
-export { REALTIME_JSON_SUBPROTOCOL, REALTIME_SUBPROTOCOL, RealtimeClient, RealtimeRequestError };
+export { REALTIME_JSON_SUBPROTOCOL, RealtimeClient, RealtimeRequestError };
 
 //# sourceMappingURL=realtime.js.map