@jgengine/core 0.7.0 → 0.9.0

package/dist/faction/factions.d.ts

@@ -0,0 +1,33 @@
+export type FactionRelation = "hostile" | "neutral" | "friendly";
+export interface FactionDef {
+    id: string;
+    relations?: Readonly<Record<string, FactionRelation>>;
+    towardSelf?: FactionRelation;
+    towardOthers?: FactionRelation;
+}
+export interface FactionGraphConfig {
+    factions: readonly FactionDef[];
+    symmetric?: boolean;
+    unaligned?: FactionRelation;
+}
+export interface FactionGraph {
+    relationBetween(observer: string | null | undefined, other: string | null | undefined): FactionRelation;
+    isHostile(observer: string | null | undefined, other: string | null | undefined): boolean;
+    isFriendly(observer: string | null | undefined, other: string | null | undefined): boolean;
+    isNeutral(observer: string | null | undefined, other: string | null | undefined): boolean;
+    has(factionId: string): boolean;
+    ids(): string[];
+}
+export declare function createFactionGraph(config: FactionGraphConfig): FactionGraph;
+export interface FactionRoster {
+    assign(entityId: string, factionId: string | null): void;
+    factionOf(entityId: string): string | null;
+    relationBetweenEntities(observer: string, other: string): FactionRelation;
+    isHostile(observer: string, other: string): boolean;
+    isFriendly(observer: string, other: string): boolean;
+    members(factionId: string): string[];
+    hostilesOf(observer: string, candidates: Iterable<string>): string[];
+    remove(entityId: string): void;
+    clear(): void;
+}
+export declare function createFactionRoster(graph: FactionGraph): FactionRoster;

package/dist/faction/factions.js

@@ -0,0 +1,76 @@
+export function createFactionGraph(config) {
+    const symmetric = config.symmetric ?? true;
+    const unaligned = config.unaligned ?? "neutral";
+    const defs = new Map();
+    for (const def of config.factions)
+        defs.set(def.id, def);
+    function relationBetween(observer, other) {
+        if (observer == null || other == null)
+            return unaligned;
+        const from = defs.get(observer);
+        const to = defs.get(other);
+        if (from === undefined || to === undefined)
+            return unaligned;
+        if (observer === other)
+            return from.towardSelf ?? "friendly";
+        const direct = from.relations?.[other];
+        if (direct !== undefined)
+            return direct;
+        if (symmetric) {
+            const mirrored = to.relations?.[observer];
+            if (mirrored !== undefined)
+                return mirrored;
+        }
+        return from.towardOthers ?? "neutral";
+    }
+    return {
+        relationBetween,
+        isHostile: (observer, other) => relationBetween(observer, other) === "hostile",
+        isFriendly: (observer, other) => relationBetween(observer, other) === "friendly",
+        isNeutral: (observer, other) => relationBetween(observer, other) === "neutral",
+        has: (factionId) => defs.has(factionId),
+        ids: () => [...defs.keys()],
+    };
+}
+export function createFactionRoster(graph) {
+    const membership = new Map();
+    function factionOf(entityId) {
+        return membership.get(entityId) ?? null;
+    }
+    function relationBetweenEntities(observer, other) {
+        return graph.relationBetween(factionOf(observer), factionOf(other));
+    }
+    return {
+        assign(entityId, factionId) {
+            if (factionId === null)
+                membership.delete(entityId);
+            else
+                membership.set(entityId, factionId);
+        },
+        factionOf,
+        relationBetweenEntities,
+        isHostile: (observer, other) => relationBetweenEntities(observer, other) === "hostile",
+        isFriendly: (observer, other) => relationBetweenEntities(observer, other) === "friendly",
+        members(factionId) {
+            const out = [];
+            for (const [entityId, id] of membership)
+                if (id === factionId)
+                    out.push(entityId);
+            return out;
+        },
+        hostilesOf(observer, candidates) {
+            const out = [];
+            for (const id of candidates) {
+                if (id !== observer && relationBetweenEntities(observer, id) === "hostile")
+                    out.push(id);
+            }
+            return out;
+        },
+        remove(entityId) {
+            membership.delete(entityId);
+        },
+        clear() {
+            membership.clear();
+        },
+    };
+}

package/dist/faction/reputation.d.ts

@@ -0,0 +1,32 @@
+import type { FactionRelation } from "./factions.js";
+export interface ReputationTier {
+    id: string;
+    min: number;
+    relation: FactionRelation;
+}
+export declare const DEFAULT_REPUTATION_TIERS: readonly ReputationTier[];
+export declare function tierForStanding(tiers: readonly ReputationTier[], standing: number): ReputationTier;
+export interface ReputationLedgerConfig {
+    tiers?: readonly ReputationTier[];
+    initial?: Readonly<Record<string, number>>;
+    min?: number;
+    max?: number;
+}
+export interface ReputationLedger {
+    standing(actorId: string, factionId: string): number;
+    hasStanding(actorId: string, factionId: string): boolean;
+    gain(actorId: string, factionId: string, amount: number): number;
+    set(actorId: string, factionId: string, standing: number): number;
+    tier(actorId: string, factionId: string): ReputationTier;
+    relation(actorId: string, factionId: string): FactionRelation;
+    standings(actorId: string): Record<string, number>;
+    reset(actorId: string, factionId?: string): void;
+}
+export declare function createReputationLedger(config?: ReputationLedgerConfig): ReputationLedger;
+export interface EffectiveRelationInput {
+    base: FactionRelation;
+    ledger: ReputationLedger;
+    actorId: string;
+    factionId: string;
+}
+export declare function effectiveRelation(input: EffectiveRelationInput): FactionRelation;

package/dist/faction/reputation.js

@@ -0,0 +1,82 @@
+export const DEFAULT_REPUTATION_TIERS = [
+    { id: "hated", min: -42000, relation: "hostile" },
+    { id: "hostile", min: -6000, relation: "hostile" },
+    { id: "unfriendly", min: -3000, relation: "neutral" },
+    { id: "neutral", min: 0, relation: "neutral" },
+    { id: "friendly", min: 3000, relation: "friendly" },
+    { id: "honored", min: 9000, relation: "friendly" },
+    { id: "revered", min: 21000, relation: "friendly" },
+    { id: "exalted", min: 42000, relation: "friendly" },
+];
+export function tierForStanding(tiers, standing) {
+    let match = tiers[0];
+    for (const tier of tiers) {
+        if (standing >= tier.min && tier.min >= match.min)
+            match = tier;
+    }
+    return match;
+}
+export function createReputationLedger(config = {}) {
+    const tiers = [...(config.tiers ?? DEFAULT_REPUTATION_TIERS)].sort((a, b) => a.min - b.min);
+    const initial = config.initial ?? {};
+    const min = config.min ?? Number.NEGATIVE_INFINITY;
+    const max = config.max ?? Number.POSITIVE_INFINITY;
+    const records = new Map();
+    function clamp(value) {
+        return Math.min(max, Math.max(min, value));
+    }
+    function standing(actorId, factionId) {
+        const stored = records.get(actorId)?.get(factionId);
+        if (stored !== undefined)
+            return stored;
+        return initial[factionId] ?? 0;
+    }
+    function store(actorId, factionId, value) {
+        const clamped = clamp(value);
+        let row = records.get(actorId);
+        if (row === undefined) {
+            row = new Map();
+            records.set(actorId, row);
+        }
+        row.set(factionId, clamped);
+        return clamped;
+    }
+    return {
+        standing,
+        hasStanding(actorId, factionId) {
+            return records.get(actorId)?.has(factionId) === true || initial[factionId] !== undefined;
+        },
+        gain(actorId, factionId, amount) {
+            return store(actorId, factionId, standing(actorId, factionId) + amount);
+        },
+        set(actorId, factionId, value) {
+            return store(actorId, factionId, value);
+        },
+        tier(actorId, factionId) {
+            return tierForStanding(tiers, standing(actorId, factionId));
+        },
+        relation(actorId, factionId) {
+            return tierForStanding(tiers, standing(actorId, factionId)).relation;
+        },
+        standings(actorId) {
+            const out = { ...initial };
+            const row = records.get(actorId);
+            if (row !== undefined)
+                for (const [factionId, value] of row)
+                    out[factionId] = value;
+            return out;
+        },
+        reset(actorId, factionId) {
+            if (factionId === undefined)
+                records.delete(actorId);
+            else
+                records.get(actorId)?.delete(factionId);
+        },
+    };
+}
+export function effectiveRelation(input) {
+    if (input.ledger.hasStanding(input.actorId, input.factionId)) {
+        return input.ledger.relation(input.actorId, input.factionId);
+    }
+    return input.base;
+}

package/dist/game/chat.d.ts

@@ -0,0 +1,68 @@
+import type { GameEvents } from "./events.js";
+import type { ChatFilter } from "./chatFilter.js";
+import type { EmotesDeps } from "./social.js";
+export type ChatChannelKind = "global" | "party" | "proximity";
+export interface ChatRateLimit {
+    count: number;
+    perMs: number;
+}
+export interface ChatChannelDef {
+    id: string;
+    kind: ChatChannelKind;
+    radius?: number;
+    historyLimit?: number;
+    rateLimit?: ChatRateLimit;
+}
+export interface ChatMessage {
+    id: string;
+    channelId: string;
+    fromUserId: string;
+    body: string;
+    at: number;
+}
+export type ChatRecipients = readonly string[] | "all";
+export type ChatSendResult = {
+    message: ChatMessage;
+    recipients: ChatRecipients;
+} | {
+    reason: string;
+};
+export interface ChatSnapshot {
+    messages: Record<string, ChatMessage[]>;
+    counter: number;
+}
+export interface Chat {
+    register(def: ChatChannelDef): void;
+    channels(): ChatChannelDef[];
+    send(fromUserId: string, channelId: string, body: string): ChatSendResult;
+    whisper(fromUserId: string, toUserId: string, body: string): ChatSendResult;
+    history(channelId: string, options?: {
+        limit?: number;
+        viewerUserId?: string;
+    }): ChatMessage[];
+    snapshot(): ChatSnapshot;
+    hydrate(data: ChatSnapshot): void;
+}
+export interface ChatDeps {
+    events: GameEvents;
+    now?: () => number;
+    party?: {
+        membersOf(userId: string): string[];
+    };
+    proximity?: EmotesDeps;
+    blockedBy?: (userId: string) => readonly string[];
+    maxBodyLength?: number;
+    defaultRateLimit?: ChatRateLimit;
+    filter?: ChatFilter;
+}
+export declare const DEFAULT_CHAT_RATE_LIMIT: ChatRateLimit;
+export declare const DEFAULT_CHAT_HISTORY_LIMIT = 100;
+export declare const DEFAULT_CHAT_BODY_LENGTH = 500;
+export declare const DEFAULT_PROXIMITY_CHAT_RADIUS = 20;
+export declare const WHISPER_CHANNEL_PREFIX = "whisper:";
+export declare function whisperChannelId(a: string, b: string): string;
+export interface ChatRateLimiter {
+    allow(key: string, atMs: number): boolean;
+}
+export declare function createChatRateLimiter(limit: ChatRateLimit): ChatRateLimiter;
+export declare function createChat(deps: ChatDeps): Chat;

package/dist/game/chat.js

@@ -0,0 +1,173 @@
+export const DEFAULT_CHAT_RATE_LIMIT = { count: 10, perMs: 10_000 };
+export const DEFAULT_CHAT_HISTORY_LIMIT = 100;
+export const DEFAULT_CHAT_BODY_LENGTH = 500;
+export const DEFAULT_PROXIMITY_CHAT_RADIUS = 20;
+export const WHISPER_CHANNEL_PREFIX = "whisper:";
+export function whisperChannelId(a, b) {
+    const [first, second] = a < b ? [a, b] : [b, a];
+    return `${WHISPER_CHANNEL_PREFIX}${first}:${second}`;
+}
+export function createChatRateLimiter(limit) {
+    const windows = new Map();
+    return {
+        allow(key, atMs) {
+            const cutoff = atMs - limit.perMs;
+            const stamps = (windows.get(key) ?? []).filter((stamp) => stamp > cutoff);
+            if (stamps.length >= limit.count) {
+                windows.set(key, stamps);
+                return false;
+            }
+            stamps.push(atMs);
+            windows.set(key, stamps);
+            return true;
+        },
+    };
+}
+const BUILTIN_CHANNELS = [
+    { id: "global", kind: "global" },
+    { id: "party", kind: "party" },
+    { id: "proximity", kind: "proximity", radius: DEFAULT_PROXIMITY_CHAT_RADIUS },
+];
+export function createChat(deps) {
+    const now = deps.now ?? Date.now;
+    const events = deps.events;
+    const maxBodyLength = deps.maxBodyLength ?? DEFAULT_CHAT_BODY_LENGTH;
+    const defaultRateLimit = deps.defaultRateLimit ?? DEFAULT_CHAT_RATE_LIMIT;
+    const blockedBy = deps.blockedBy ?? (() => []);
+    const filter = deps.filter;
+    const channelDefs = new Map();
+    for (const def of BUILTIN_CHANNELS)
+        channelDefs.set(def.id, { ...def });
+    const messagesByChannel = new Map();
+    const limiters = new Map();
+    let counter = 0;
+    function limiterFor(channelId, rateLimit) {
+        let limiter = limiters.get(channelId);
+        if (limiter === undefined) {
+            limiter = createChatRateLimiter(rateLimit);
+            limiters.set(channelId, limiter);
+        }
+        return limiter;
+    }
+    function hasBlocked(userId, targetUserId) {
+        return blockedBy(userId).includes(targetUserId);
+    }
+    function resolveRecipients(fromUserId, channelId, def) {
+        if (channelId.startsWith(WHISPER_CHANNEL_PREFIX)) {
+            const pair = channelId.slice(WHISPER_CHANNEL_PREFIX.length).split(":");
+            const toUserId = pair.find((userId) => userId !== fromUserId);
+            if (pair.length !== 2 || toUserId === undefined || !pair.includes(fromUserId)) {
+                return { reason: "not a participant of this whisper" };
+            }
+            if (hasBlocked(toUserId, fromUserId) || hasBlocked(fromUserId, toUserId)) {
+                return { reason: "blocked" };
+            }
+            return { recipients: [toUserId] };
+        }
+        if (def === null)
+            return { reason: `unknown channel "${channelId}"` };
+        if (def.kind === "global")
+            return { recipients: "all" };
+        if (def.kind === "party") {
+            const members = deps.party?.membersOf(fromUserId) ?? [];
+            if (!members.includes(fromUserId))
+                return { reason: "not in a party" };
+            return {
+                recipients: members.filter((userId) => userId !== fromUserId && !hasBlocked(userId, fromUserId)),
+            };
+        }
+        const proximity = deps.proximity;
+        if (proximity === undefined)
+            return { reason: "proximity chat not configured" };
+        const origin = proximity.entities.get(fromUserId);
+        if (origin === null)
+            return { reason: `entity "${fromUserId}" is not spawned` };
+        const nearby = proximity.spatial.inRadius(origin.position, def.radius ?? DEFAULT_PROXIMITY_CHAT_RADIUS, (id) => id !== fromUserId && proximity.entities.get(id)?.role === "player");
+        return { recipients: nearby.filter((userId) => !hasBlocked(userId, fromUserId)) };
+    }
+    function append(channelId, message, historyLimit) {
+        const ring = messagesByChannel.get(channelId) ?? [];
+        ring.push(message);
+        if (ring.length > historyLimit)
+            ring.splice(0, ring.length - historyLimit);
+        messagesByChannel.set(channelId, ring);
+    }
+    function sendResolved(fromUserId, channelId, body, def) {
+        const trimmed = body.trim();
+        if (trimmed.length === 0)
+            return { reason: "empty message" };
+        if (trimmed.length > maxBodyLength)
+            return { reason: "message too long" };
+        let filteredBody = trimmed;
+        if (filter !== undefined) {
+            const filtered = filter.apply(trimmed);
+            if (!filtered.ok)
+                return { reason: "filtered" };
+            filteredBody = filtered.body;
+        }
+        const resolved = resolveRecipients(fromUserId, channelId, def);
+        if ("reason" in resolved)
+            return resolved;
+        const at = now();
+        const rateLimit = def?.rateLimit ?? defaultRateLimit;
+        if (!limiterFor(channelId, rateLimit).allow(`${fromUserId}|${channelId}`, at)) {
+            return { reason: "rate limited" };
+        }
+        counter += 1;
+        const message = {
+            id: `msg_${counter}`,
+            channelId,
+            fromUserId,
+            body: filteredBody,
+            at,
+        };
+        append(channelId, message, def?.historyLimit ?? DEFAULT_CHAT_HISTORY_LIMIT);
+        const event = { ...message };
+        if (resolved.recipients !== "all")
+            event.recipients = resolved.recipients;
+        events.emit("chat.message", event);
+        return { message, recipients: resolved.recipients };
+    }
+    return {
+        register(def) {
+            channelDefs.set(def.id, { ...def });
+            limiters.delete(def.id);
+        },
+        channels() {
+            return Array.from(channelDefs.values(), (def) => ({ ...def }));
+        },
+        send(fromUserId, channelId, body) {
+            const def = channelDefs.get(channelId) ?? null;
+            return sendResolved(fromUserId, channelId, body, def);
+        },
+        whisper(fromUserId, toUserId, body) {
+            if (fromUserId === toUserId)
+                return { reason: "cannot whisper yourself" };
+            const channelId = whisperChannelId(fromUserId, toUserId);
+            return sendResolved(fromUserId, channelId, body, channelDefs.get(channelId) ?? null);
+        },
+        history(channelId, options) {
+            const ring = messagesByChannel.get(channelId) ?? [];
+            const viewerUserId = options?.viewerUserId;
+            const visible = viewerUserId === undefined
+                ? ring
+                : ring.filter((message) => !hasBlocked(viewerUserId, message.fromUserId));
+            const limit = options?.limit;
+            return limit === undefined ? visible.slice() : visible.slice(-limit);
+        },
+        snapshot() {
+            const messages = {};
+            for (const [channelId, ring] of messagesByChannel) {
+                messages[channelId] = ring.map((message) => ({ ...message }));
+            }
+            return { messages, counter };
+        },
+        hydrate(data) {
+            messagesByChannel.clear();
+            for (const [channelId, ring] of Object.entries(data.messages)) {
+                messagesByChannel.set(channelId, ring.map((message) => ({ ...message })));
+            }
+            counter = data.counter;
+        },
+    };
+}

package/dist/game/chatFilter.d.ts

@@ -0,0 +1,15 @@
+export interface ChatFilterConfig {
+    blockedWords: readonly string[];
+    mode?: "mask" | "reject";
+    mask?: string;
+}
+export interface ChatFilterResult {
+    ok: boolean;
+    body: string;
+    matched: readonly string[];
+}
+export interface ChatFilter {
+    apply(body: string): ChatFilterResult;
+}
+export declare function normalizeChatText(text: string): string;
+export declare function createChatFilter(config: ChatFilterConfig): ChatFilter;

package/dist/game/chatFilter.js

@@ -0,0 +1,55 @@
+const LEET_SUBSTITUTIONS = {
+    "0": "o",
+    "1": "i",
+    "3": "e",
+    "4": "a",
+    "5": "s",
+    "7": "t",
+    "@": "a",
+    $: "s",
+    "!": "i",
+};
+const TOKEN_PATTERN = /[\p{L}\p{N}@$!]+/gu;
+export function normalizeChatText(text) {
+    let normalized = "";
+    for (const char of text.toLowerCase()) {
+        normalized += LEET_SUBSTITUTIONS[char] ?? char;
+    }
+    return normalized;
+}
+export function createChatFilter(config) {
+    const mode = config.mode ?? "mask";
+    const mask = config.mask ?? "*";
+    const blockedByNormalized = new Map();
+    for (const word of config.blockedWords) {
+        blockedByNormalized.set(normalizeChatText(word), word);
+    }
+    return {
+        apply(body) {
+            if (blockedByNormalized.size === 0)
+                return { ok: true, body, matched: [] };
+            const hit = new Set();
+            let masked = "";
+            let cursor = 0;
+            for (const token of body.matchAll(TOKEN_PATTERN)) {
+                const word = token[0];
+                const start = token.index;
+                const blockedWord = blockedByNormalized.get(normalizeChatText(word));
+                if (blockedWord === undefined)
+                    continue;
+                hit.add(blockedWord);
+                if (mode === "reject")
+                    continue;
+                masked += body.slice(cursor, start) + mask.repeat(word.length);
+                cursor = start + word.length;
+            }
+            if (hit.size === 0)
+                return { ok: true, body, matched: [] };
+            const matched = [...new Set(config.blockedWords)].filter((word) => hit.has(word));
+            if (mode === "reject")
+                return { ok: false, body, matched };
+            masked += body.slice(cursor);
+            return { ok: true, body: masked, matched };
+        },
+    };
+}

package/dist/game/controlGate.d.ts

@@ -0,0 +1,4 @@
+import type { GameContext } from "../runtime/gameContext.js";
+export declare const PLAY_CONTROLS_STORE_KEY = "jg.playControls";
+export declare function setPlayControlsActive(ctx: GameContext, active: boolean): void;
+export declare function playControlsActive(ctx: GameContext): boolean;

package/dist/game/controlGate.js

@@ -0,0 +1,7 @@
+export const PLAY_CONTROLS_STORE_KEY = "jg.playControls";
+export function setPlayControlsActive(ctx, active) {
+    ctx.game.store.set(PLAY_CONTROLS_STORE_KEY, active);
+}
+export function playControlsActive(ctx) {
+    return ctx.game.store.get(PLAY_CONTROLS_STORE_KEY) !== false;
+}

package/dist/game/defineGame.d.ts

@@ -1,13 +1,17 @@
 import type { ActionCodesMap } from "../input/actionBindings.js";
+import type { GameFeedOptions } from "./feed.js";
 import type { ItemTraits } from "../inventory/inventoryModel.js";
 import type { StorageTier } from "../inventory/storageTier.js";
 import type { SaveConfig } from "../runtime/save.js";
-import type { AssetCatalog, ModelAssetRef } from "../scene/assetCatalog.js";
+import { type AssetCatalog, type ModelAssetRef } from "../scene/assetCatalog.js";
 import { type EntityStore } from "../scene/entityStore.js";
 import type { TimeConfig } from "../time/simClock.js";
 import type { WorldFeature } from "../world/features.js";
 export interface PhysicsConfig {
     gravity?: number;
+    jumpVelocity?: number;
+    /** Opt placed scene objects into projectile raycasts as blocking cover AABBs. Default false — enabling changes where shots land. */
+    projectileObstacles?: boolean;
 }
 export interface InventoryDeclaration {
     slots: number;
@@ -35,6 +39,8 @@ export interface GameDefinition<TAssetRef extends ModelAssetRef = ModelAssetRef,
     physics?: PhysicsConfig;
     /** Simulation clock: real→game time scale, selectable speeds, calendar. Exposed as `ctx.time`; the shell feeds its scaled dt to `loop.onTick`. */
     time?: TimeConfig;
+    /** Per-action ring-buffer capacity for `ctx.game.feed`. Default 20. */
+    feed?: GameFeedOptions;
     inventories?: Record<string, InventoryDeclaration>;
     input?: ActionCodesMap;
     server?: GameServerConfig;
@@ -42,5 +48,7 @@ export interface GameDefinition<TAssetRef extends ModelAssetRef = ModelAssetRef,
     ui?: unknown;
     loop?: GameLoop<any>;
 }
-export type GameDefinitionConfig<TAssetRef extends ModelAssetRef = ModelAssetRef, TMultiplayer = unknown> = Omit<GameDefinition<TAssetRef, TMultiplayer>, "scene">;
+export type GameDefinitionConfig<TAssetRef extends ModelAssetRef = ModelAssetRef, TMultiplayer = unknown> = Omit<GameDefinition<TAssetRef, TMultiplayer>, "scene" | "assets"> & {
+    assets?: AssetCatalog<TAssetRef>;
+};
 export declare function defineGame<TAssetRef extends ModelAssetRef, TMultiplayer>(config: GameDefinitionConfig<TAssetRef, TMultiplayer>): GameDefinition<TAssetRef, TMultiplayer>;

package/dist/game/defineGame.js

@@ -1,7 +1,8 @@
+import { createAssetCatalog } from "../scene/assetCatalog.js";
 import { createEntityStore } from "../scene/entityStore.js";
 export function defineGame(config) {
     if (config.name.trim().length === 0) {
         throw new Error("defineGame: name must be non-empty");
     }
-    return { ...config, scene: createEntityStore() };
+    return { ...config, scene: createEntityStore(), assets: config.assets ?? createAssetCatalog() };
 }

package/dist/game/events.d.ts

@@ -63,6 +63,28 @@ export interface SocialPartyLeftEvent {
     userId: string;
     partyId: string;
 }
+export interface SocialWorldInvitedEvent {
+    inviteId: string;
+    fromUserId: string;
+    toUserId: string;
+    serverId: string;
+    joinCode?: string;
+}
+export interface SocialWorldAcceptedEvent {
+    inviteId: string;
+    userId: string;
+    fromUserId: string;
+    serverId: string;
+    joinCode?: string;
+}
+export interface ChatMessageEvent {
+    id: string;
+    channelId: string;
+    fromUserId: string;
+    body: string;
+    at: number;
+    recipients?: readonly string[];
+}
 export interface StatLevelUpEvent {
     userId: string;
     stat: string;
@@ -87,6 +109,10 @@ export interface CombatTelegraphEvent {
     windupMs: number;
     kind: string;
 }
+export interface CombatTelegraphCancelledEvent {
+    /** The `combat.telegraph` event id whose decal should disappear early. */
+    id: number;
+}
 export interface CombatHitReactionEvent {
     instanceId?: string;
     position: [number, number, number];
@@ -134,10 +160,15 @@ export interface FormChangedEvent {
     instanceId: string;
     formId: string | null;
 }
+export interface AudioPlayEvent {
+    sound: string;
+    at?: readonly [number, number, number];
+}
 export interface GameEventMap {
     "entity.died": EntityDiedEvent;
     "entity.floatText": EntityFloatTextEvent;
     "combat.telegraph": CombatTelegraphEvent;
+    "combat.telegraphCancelled": CombatTelegraphCancelledEvent;
     "combat.hitReaction": CombatHitReactionEvent;
     "loot.granted": LootGrantedEvent;
     "inventory.added": InventoryAddedEvent;
@@ -147,6 +178,9 @@ export interface GameEventMap {
     "social.friend.added": SocialFriendAddedEvent;
     "social.party.joined": SocialPartyJoinedEvent;
     "social.party.left": SocialPartyLeftEvent;
+    "social.world.invited": SocialWorldInvitedEvent;
+    "social.world.accepted": SocialWorldAcceptedEvent;
+    "chat.message": ChatMessageEvent;
     "stat.levelUp": StatLevelUpEvent;
     "projectile.settled": ProjectileSettledEvent;
     "worldItem.dropped": WorldItemDroppedEvent;
@@ -155,6 +189,7 @@ export interface GameEventMap {
     "emote.played": EmotePlayedEvent;
     "possession.swapped": PossessionSwappedEvent;
     "form.changed": FormChangedEvent;
+    "audio.play": AudioPlayEvent;
 }
 export type GameEventHandler<TPayload> = (payload: TPayload) => void;
 export interface GameEvents<TMap extends GameEventMap = GameEventMap> {