@jgengine/core 0.7.0 → 0.9.0

package/dist/game/progression.d.ts

@@ -40,6 +40,7 @@ export interface LevelingConfig {
     startLevel?: number;
     xpStat?: string;
     levelStat?: string;
+    thresholdMode?: "perLevel" | "cumulative";
 }
 export interface LevelingStatAccess {
     get(userId: string, statId: string): {

package/dist/game/progression.js

@@ -60,8 +60,13 @@ export function leveling(config) {
     const startLevel = config.startLevel ?? 1;
     const xpStat = config.xpStat ?? "xp";
     const levelStat = config.levelStat ?? "level";
-    const xpForLevel = (level) => evalCurve(config.xpForLevel, level);
-    const resolve = (level, xp) => {
+    const thresholdMode = config.thresholdMode ?? "perLevel";
+    const xpForLevel = (level) => {
+        if (thresholdMode === "cumulative" && level <= startLevel)
+            return 0;
+        return evalCurve(config.xpForLevel, level);
+    };
+    const resolvePerLevel = (level, xp) => {
         let currentLevel = level;
         let currentXp = xp;
         let levelsGained = 0;
@@ -79,6 +84,22 @@ export function leveling(config) {
             levelsGained,
         };
     };
+    const resolveCumulative = (level, xp) => {
+        let currentLevel = level;
+        let levelsGained = 0;
+        while (currentLevel < maxLevel && xp >= xpForLevel(currentLevel + 1)) {
+            currentLevel += 1;
+            levelsGained += 1;
+        }
+        const capped = currentLevel >= maxLevel;
+        return {
+            level: currentLevel,
+            xp: capped ? xpForLevel(maxLevel) : xp,
+            xpMax: capped ? xpForLevel(maxLevel) : xpForLevel(currentLevel + 1),
+            levelsGained,
+        };
+    };
+    const resolve = (level, xp) => thresholdMode === "cumulative" ? resolveCumulative(level, xp) : resolvePerLevel(level, xp);
     const grantXp = (access, userId, amount, onLevelUp) => {
         const xp = access.get(userId, xpStat);
         const level = access.get(userId, levelStat);

package/dist/game/quest.d.ts

@@ -65,7 +65,7 @@ export interface QuestJournalDeps {
     partyMembersNear?(userId: string, radius: number): string[];
 }
 export interface QuestJournal {
-    register(catalog: QuestDef[] | Record<string, QuestDef>): void;
+    register(catalog: readonly QuestDef[] | Record<string, QuestDef>): void;
     has(questId: string): boolean;
     canAccept(userId: string, questId: string): {
         reason: string;
@@ -126,7 +126,11 @@ export interface QuestEvaluator {
 export declare function applyQuestRewards(rewards: QuestRewards, appliers: {
     grantXp?(amount: number): void;
     grantEconomy?(currencyId: string, amount: number): void;
-    grantItem?(inventoryId: string, itemId: string, count: number): void;
+    grantItem?(inventoryId: string, itemId: string, count: number): {
+        reason: string;
+    } | null | void;
     grantUnlock?(unlockId: string): void;
-}): void;
+}): {
+    reason: string;
+} | null;
 export declare function createQuestEvaluator(defs: QuestDef[] | Record<string, QuestDef>): QuestEvaluator;

package/dist/game/quest.js

@@ -72,17 +72,20 @@ export function createQuestJournal(deps) {
         return null;
     }
     function applyRewards(userId, rewards) {
+        for (const entry of rewards.items ?? []) {
+            const fail = deps.rewards.grantItem(userId, entry.inventory, entry.item, entry.count);
+            if (fail !== null)
+                return fail;
+        }
         if (rewards.xp)
             deps.rewards.grantXp(userId, rewards.xp.amount);
         for (const [currencyId, amount] of Object.entries(rewards.economy ?? {})) {
             deps.rewards.grantEconomy(userId, currencyId, amount);
         }
-        for (const entry of rewards.items ?? []) {
-            deps.rewards.grantItem(userId, entry.inventory, entry.item, entry.count);
-        }
         for (const unlockId of rewards.unlocks ?? []) {
             deps.rewards.grantUnlock(userId, unlockId);
         }
+        return null;
     }
     function turnIn(userId, questId) {
         const denied = canTurnIn(userId, questId);
@@ -90,9 +93,12 @@ export function createQuestJournal(deps) {
             return denied;
         const def = catalog.get(questId);
         const state = users.get(userId).get(questId);
+        if (def.rewards) {
+            const fail = applyRewards(userId, def.rewards);
+            if (fail !== null)
+                return fail;
+        }
         state.status = "completed";
-        if (def.rewards)
-            applyRewards(userId, def.rewards);
         deps.events.emit("quest.completed", { userId, questId });
         for (const nextQuestId of def.rewards?.quests ?? []) {
             if (canAccept(userId, nextQuestId) === null)
@@ -227,17 +233,20 @@ export function createQuestJournal(deps) {
     };
 }
 export function applyQuestRewards(rewards, appliers) {
+    for (const entry of rewards.items ?? []) {
+        const fail = appliers.grantItem?.(entry.inventory, entry.item, entry.count);
+        if (fail != null && typeof fail === "object" && "reason" in fail)
+            return fail;
+    }
     if (rewards.xp)
         appliers.grantXp?.(rewards.xp.amount);
     for (const [currencyId, amount] of Object.entries(rewards.economy ?? {})) {
         appliers.grantEconomy?.(currencyId, amount);
     }
-    for (const entry of rewards.items ?? []) {
-        appliers.grantItem?.(entry.inventory, entry.item, entry.count);
-    }
     for (const unlockId of rewards.unlocks ?? []) {
         appliers.grantUnlock?.(unlockId);
     }
+    return null;
 }
 function toWorking(state) {
     const working = new Map();

package/dist/game/race.d.ts

@@ -3,18 +3,36 @@ export interface Checkpoint {
     center: readonly [number, number, number];
     half: readonly [number, number, number];
 }
+export interface RaceForkRoute {
+    id: string;
+    checkpoints: readonly Checkpoint[];
+}
+/**
+ * An alternate-route section (#286.3): after passing mainline checkpoint `afterIndex`, a racer commits
+ * to whichever route's first checkpoint they hit, runs its checkpoints in order, and rejoins at
+ * mainline `afterIndex + 1`. Every completed route contributes exactly one checkpoint of `progress`
+ * regardless of length, and each hit records a split — so route time accounting comes for free.
+ */
+export interface RaceFork {
+    id: string;
+    /** Mainline checkpoint index the fork opens after; must be before the finish line. */
+    afterIndex: number;
+    routes: readonly RaceForkRoute[];
+}
 export interface RaceTrackConfig {
     checkpoints: readonly Checkpoint[];
     laps?: number;
+    forks?: readonly RaceFork[];
 }
 export interface RaceTrack {
     readonly checkpoints: readonly Checkpoint[];
     readonly laps: number;
+    readonly forks: readonly RaceFork[];
 }
 /**
  * A race track is an ordered ring of checkpoint trigger volumes plus a lap count. The final checkpoint
  * is the lap/finish line: a racer completes a lap by passing all checkpoints in order and hitting the
- * last one.
+ * last one. `forks` splice alternate route segments between mainline checkpoints.
  */
 export declare function raceTrack(config: RaceTrackConfig): RaceTrack;
 export interface RacerProgress {
@@ -28,6 +46,13 @@ export interface RacerProgress {
     finishTime: number | null;
     eliminated: boolean;
     splits: readonly number[];
+    /** Fork id → route id last taken through it. */
+    routesTaken: Readonly<Record<string, string>>;
+    /** Route the racer is currently inside, or `null` on the mainline. */
+    activeRoute: {
+        forkId: string;
+        routeId: string;
+    } | null;
 }
 export type RaceEvent = {
     type: "checkpoint.hit";
@@ -35,6 +60,18 @@ export type RaceEvent = {
     checkpoint: number;
     lap: number;
     time: number;
+    /** Set when the hit is a fork-route checkpoint (`checkpoint` is then the fork's `afterIndex`). */
+    fork?: {
+        forkId: string;
+        routeId: string;
+        index: number;
+    };
+} | {
+    type: "fork.taken";
+    racerId: string;
+    forkId: string;
+    routeId: string;
+    time: number;
 } | {
     type: "lap.completed";
     racerId: string;
@@ -69,6 +106,7 @@ export interface RaceStateConfig {
  * volumes. It emits `checkpoint.hit` / `lap.completed` / `position.changed` / `race.finished`, keeps
  * cumulative split times for PB deltas, resolves a pluggable win condition (first-past-post, round-cut,
  * derby last-standing), and `resetToCheckpoint` hands back a respawn pose at the racer's last checkpoint.
+ * `removeRacer` drops a racer mid-race and `reset` returns the whole instance to its pre-race state for reuse.
  */
 export declare class RaceState {
     private readonly track;
@@ -79,12 +117,17 @@ export declare class RaceState {
     private finalRanking;
     constructor(config: RaceStateConfig);
     addRacer(racerId: string, startTime?: number): void;
+    /** Removes a racer's progress/standing and renumbers the remaining field's positions; a no-op for an unknown id. */
+    removeRacer(racerId: string): void;
+    /** Clears all racer progress and finish state back to construction time; `track` and `win` are untouched, so the same instance can run another race. */
+    reset(): void;
     eliminate(racerId: string): void;
     get finished(): boolean;
     get ranking(): readonly string[];
     progressOf(racerId: string): RacerProgress | null;
     private snapshot;
     standings(): readonly RacerProgress[];
+    private expectedCheckpoint;
     resetToCheckpoint(racerId: string): {
         position: [number, number, number];
         heading: number;

package/dist/game/race.js

@@ -1,10 +1,24 @@
 /**
  * A race track is an ordered ring of checkpoint trigger volumes plus a lap count. The final checkpoint
  * is the lap/finish line: a racer completes a lap by passing all checkpoints in order and hitting the
- * last one.
+ * last one. `forks` splice alternate route segments between mainline checkpoints.
  */
 export function raceTrack(config) {
-    return { checkpoints: config.checkpoints, laps: Math.max(1, Math.floor(config.laps ?? 1)) };
+    const checkpoints = config.checkpoints;
+    const forks = config.forks ?? [];
+    for (const fork of forks) {
+        if (fork.afterIndex < 0 || fork.afterIndex >= checkpoints.length - 1) {
+            throw new Error(`race fork "${fork.id}" afterIndex ${fork.afterIndex} must sit before the finish line`);
+        }
+        if (fork.routes.length < 2)
+            throw new Error(`race fork "${fork.id}" needs at least two routes`);
+        for (const route of fork.routes) {
+            if (route.checkpoints.length === 0) {
+                throw new Error(`race fork "${fork.id}" route "${route.id}" needs at least one checkpoint`);
+            }
+        }
+    }
+    return { checkpoints, laps: Math.max(1, Math.floor(config.laps ?? 1)), forks };
 }
 function rankIds(standings) {
     return standings.map((s) => s.racerId);
@@ -50,6 +64,7 @@ function distanceToNext(point, cp) {
  * volumes. It emits `checkpoint.hit` / `lap.completed` / `position.changed` / `race.finished`, keeps
  * cumulative split times for PB deltas, resolves a pluggable win condition (first-past-post, round-cut,
  * derby last-standing), and `resetToCheckpoint` hands back a respawn pose at the racer's last checkpoint.
+ * `removeRacer` drops a racer mid-race and `reset` returns the whole instance to its pre-race state for reuse.
  */
 export class RaceState {
     track;
@@ -77,9 +92,32 @@ export class RaceState {
             eliminated: false,
             startTime,
             splits: [],
+            fork: null,
+            routesTaken: {},
+            forksDone: {},
+            lastHit: null,
         });
         this.order.push(racerId);
     }
+    /** Removes a racer's progress/standing and renumbers the remaining field's positions; a no-op for an unknown id. */
+    removeRacer(racerId) {
+        if (!this.racers.delete(racerId))
+            return;
+        const idx = this.order.indexOf(racerId);
+        if (idx >= 0)
+            this.order.splice(idx, 1);
+        const remaining = this.order.map((id) => this.racers.get(id)).sort((a, b) => this.compare(a, b, null));
+        remaining.forEach((r, i) => {
+            r.position = i + 1;
+        });
+    }
+    /** Clears all racer progress and finish state back to construction time; `track` and `win` are untouched, so the same instance can run another race. */
+    reset() {
+        this.racers.clear();
+        this.order.length = 0;
+        this.raceFinished = false;
+        this.finalRanking = [];
+    }
     eliminate(racerId) {
         const r = this.racers.get(racerId);
         if (r !== undefined)
@@ -96,6 +134,7 @@ export class RaceState {
         return r === null || r === undefined ? null : this.snapshot(r);
     }
     snapshot(r) {
+        const activeFork = r.fork === null ? null : this.track.forks[r.fork.forkIndex];
         return {
             racerId: r.racerId,
             lap: r.lap,
@@ -107,6 +146,10 @@ export class RaceState {
             finishTime: r.finishTime,
             eliminated: r.eliminated,
             splits: [...r.splits],
+            routesTaken: { ...r.routesTaken },
+            activeRoute: activeFork === null || r.fork === null
+                ? null
+                : { forkId: activeFork.id, routeId: activeFork.routes[r.fork.routeIndex].id },
         };
     }
     standings() {
@@ -116,16 +159,24 @@ export class RaceState {
             .sort((a, b) => this.compare(a, b, null))
             .map((r) => this.snapshot(r));
     }
+    expectedCheckpoint(r) {
+        if (r.fork !== null) {
+            const fork = this.track.forks[r.fork.forkIndex];
+            const route = fork.routes[r.fork.routeIndex];
+            return route.checkpoints[r.fork.nextRouteCheckpoint] ?? this.track.checkpoints[r.nextCheckpoint] ?? null;
+        }
+        return this.track.checkpoints[r.nextCheckpoint] ?? null;
+    }
     resetToCheckpoint(racerId) {
         const r = this.racers.get(racerId);
         if (r === undefined)
             return null;
-        const cps = this.track.checkpoints;
-        const idx = r.lastCheckpoint >= 0 ? r.lastCheckpoint : 0;
-        const cp = cps[idx];
+        const cp = r.lastHit ?? this.track.checkpoints[0];
         if (cp === undefined)
             return null;
-        const next = cps[(idx + 1) % cps.length];
+        let next = this.expectedCheckpoint(r) ?? cp;
+        if (next === cp)
+            next = this.track.checkpoints[1 % this.track.checkpoints.length] ?? cp;
         const heading = Math.atan2(next.center[0] - cp.center[0], next.center[2] - cp.center[2]);
         return { position: [cp.center[0], cp.center[1], cp.center[2]], heading };
     }
@@ -141,10 +192,11 @@ export class RaceState {
         if (positions !== null) {
             const pa = positions.get(a.racerId);
             const pb = positions.get(b.racerId);
-            const cps = this.track.checkpoints;
-            if (pa !== undefined && pb !== undefined && cps.length > 0) {
-                const da = distanceToNext(pa, cps[a.nextCheckpoint]);
-                const db = distanceToNext(pb, cps[b.nextCheckpoint]);
+            const ca = this.expectedCheckpoint(a);
+            const cb = this.expectedCheckpoint(b);
+            if (pa !== undefined && pb !== undefined && ca !== null && cb !== null) {
+                const da = distanceToNext(pa, ca);
+                const db = distanceToNext(pb, cb);
                 if (da !== db)
                     return da - db;
             }
@@ -157,6 +209,8 @@ export class RaceState {
         const cps = this.track.checkpoints;
         const count = cps.length;
         if (count > 0) {
+            const forks = this.track.forks;
+            const maxSteps = count + forks.reduce((sum, fork) => sum + Math.max(...fork.routes.map((route) => route.checkpoints.length)), 0) + 2;
             for (const id of this.order) {
                 const r = this.racers.get(id);
                 if (r.finished || r.eliminated)
@@ -165,10 +219,61 @@ export class RaceState {
                 if (pos === undefined)
                     continue;
                 let guard = 0;
-                while (guard < count && insideAabb(pos, cps[r.nextCheckpoint])) {
+                while (guard < maxSteps) {
                     guard += 1;
+                    if (r.fork !== null) {
+                        const fork = forks[r.fork.forkIndex];
+                        const route = fork.routes[r.fork.routeIndex];
+                        const cp = route.checkpoints[r.fork.nextRouteCheckpoint];
+                        if (!insideAabb(pos, cp))
+                            break;
+                        r.lastHit = cp;
+                        r.progress += 1 / route.checkpoints.length;
+                        r.splits.push(now - r.startTime);
+                        events.push({
+                            type: "checkpoint.hit",
+                            racerId: id,
+                            checkpoint: fork.afterIndex,
+                            lap: r.lap,
+                            time: now,
+                            fork: { forkId: fork.id, routeId: route.id, index: r.fork.nextRouteCheckpoint },
+                        });
+                        r.fork.nextRouteCheckpoint += 1;
+                        if (r.fork.nextRouteCheckpoint >= route.checkpoints.length) {
+                            r.forksDone[fork.id] = true;
+                            r.fork = null;
+                        }
+                        continue;
+                    }
+                    let tookRoute = false;
+                    for (let forkIndex = 0; forkIndex < forks.length; forkIndex += 1) {
+                        const fork = forks[forkIndex];
+                        if (fork.afterIndex !== r.lastCheckpoint || r.nextCheckpoint !== fork.afterIndex + 1)
+                            continue;
+                        if (r.forksDone[fork.id] === true)
+                            continue;
+                        for (let routeIndex = 0; routeIndex < fork.routes.length; routeIndex += 1) {
+                            const route = fork.routes[routeIndex];
+                            if (!insideAabb(pos, route.checkpoints[0]))
+                                continue;
+                            r.fork = { forkIndex, routeIndex, nextRouteCheckpoint: 0 };
+                            r.routesTaken[fork.id] = route.id;
+                            events.push({ type: "fork.taken", racerId: id, forkId: fork.id, routeId: route.id, time: now });
+                            tookRoute = true;
+                            break;
+                        }
+                        if (tookRoute)
+                            break;
+                    }
+                    if (tookRoute)
+                        continue;
+                    const cp = cps[r.nextCheckpoint];
+                    if (!insideAabb(pos, cp))
+                        break;
                     const hit = r.nextCheckpoint;
                     r.lastCheckpoint = hit;
+                    r.lastHit = cp;
+                    r.forksDone = {};
                     r.progress += 1;
                     r.splits.push(now - r.startTime);
                     events.push({ type: "checkpoint.hit", racerId: id, checkpoint: hit, lap: r.lap, time: now });

package/dist/game/recordBook.d.ts

@@ -0,0 +1,29 @@
+export interface RecordStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export type RecordDirection = "lower" | "higher";
+export interface RecordBookConfig<K extends string> {
+    readonly key: string;
+    readonly fields: Readonly<Record<K, RecordDirection>>;
+    readonly storage?: RecordStorage | null;
+}
+export interface RecordSubmission<K extends string> {
+    readonly improved: readonly K[];
+    readonly best: Readonly<Partial<Record<K, number>>>;
+}
+export interface RecordBook<K extends string> {
+    best(): Readonly<Partial<Record<K, number>>>;
+    bestOf(field: K): number | null;
+    submit(run: Readonly<Partial<Record<K, number>>>): RecordSubmission<K>;
+    clear(): void;
+}
+/**
+ * A personal-best record book: named numeric fields each racing toward "lower"
+ * (times) or "higher" (scores, streaks), persisted through a structural
+ * key-value storage (pass `localStorage` in a browser, a stub in tests, or
+ * `null` for in-memory only). Corrupt or unavailable storage degrades to an
+ * empty book — a record write never throws into a game tick.
+ */
+export declare function createRecordBook<K extends string>(config: RecordBookConfig<K>): RecordBook<K>;

package/dist/game/recordBook.js

@@ -0,0 +1,86 @@
+function loadStored(config, storage) {
+    if (storage === null)
+        return {};
+    let raw;
+    try {
+        raw = storage.getItem(config.key);
+    }
+    catch {
+        return {};
+    }
+    if (raw === null)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return {};
+    const best = {};
+    for (const field of Object.keys(config.fields)) {
+        const value = parsed[field];
+        if (typeof value === "number" && Number.isFinite(value))
+            best[field] = value;
+    }
+    return best;
+}
+/**
+ * A personal-best record book: named numeric fields each racing toward "lower"
+ * (times) or "higher" (scores, streaks), persisted through a structural
+ * key-value storage (pass `localStorage` in a browser, a stub in tests, or
+ * `null` for in-memory only). Corrupt or unavailable storage degrades to an
+ * empty book — a record write never throws into a game tick.
+ */
+export function createRecordBook(config) {
+    const storage = config.storage ?? null;
+    let best = loadStored(config, storage);
+    function persist() {
+        if (storage === null)
+            return;
+        try {
+            storage.setItem(config.key, JSON.stringify(best));
+        }
+        catch {
+            return;
+        }
+    }
+    return {
+        best() {
+            return { ...best };
+        },
+        bestOf(field) {
+            return best[field] ?? null;
+        },
+        submit(run) {
+            const improved = [];
+            for (const field of Object.keys(config.fields)) {
+                const value = run[field];
+                if (value === undefined || !Number.isFinite(value))
+                    continue;
+                const current = best[field];
+                const beats = current === undefined || (config.fields[field] === "lower" ? value < current : value > current);
+                if (beats) {
+                    best[field] = value;
+                    improved.push(field);
+                }
+            }
+            if (improved.length > 0)
+                persist();
+            return { improved, best: { ...best } };
+        },
+        clear() {
+            best = {};
+            if (storage === null)
+                return;
+            try {
+                storage.removeItem(config.key);
+            }
+            catch {
+                return;
+            }
+        },
+    };
+}

package/dist/game/social.d.ts

@@ -23,6 +23,7 @@ export interface SocialDeps {
     presence?: (userId: string) => PresenceInfo;
     now?: () => number;
     emotes?: EmotesDeps;
+    worldInviteTtlMs?: number;
 }
 export interface FriendEntry {
     userId: string;
@@ -32,6 +33,10 @@ export interface FriendsSnapshot {
     friends: string[];
     blocked: string[];
 }
+export interface FriendRequestEntry {
+    requestId: string;
+    fromUserId: string;
+}
 export interface Friends {
     canRequest(fromUserId: string, toUserId: string): {
         reason: string;
@@ -44,9 +49,11 @@ export interface Friends {
     accept(userId: string, requestId: string): {
         reason: string;
     } | null;
+    decline(userId: string, requestId: string): void;
     remove(userId: string, friendUserId: string): void;
     block(userId: string, targetUserId: string): void;
     list(userId: string): FriendEntry[];
+    requestsFor(userId: string): FriendRequestEntry[];
     snapshot(userId: string): FriendsSnapshot;
     hydrate(userId: string, data: FriendsSnapshot): void;
 }
@@ -59,6 +66,11 @@ export interface PartyConfig {
     maxMembers: number;
     inviteTtlMs?: number;
 }
+export interface PartyInviteEntry {
+    inviteId: string;
+    fromUserId: string;
+    createdAt: number;
+}
 export interface Party {
     register(config: PartyConfig): void;
     canInvite(fromUserId: string, toUserId: string): {
@@ -72,6 +84,7 @@ export interface Party {
     accept(userId: string, inviteId: string): {
         reason: string;
     } | null;
+    decline(userId: string, inviteId: string): void;
     kick(leaderUserId: string, memberUserId: string): {
         reason: string;
     } | null;
@@ -81,6 +94,7 @@ export interface Party {
     } | null;
     list(userId: string): PartyMemberEntry[];
     membersOf(userId: string): string[];
+    invitesFor(userId: string): PartyInviteEntry[];
 }
 export declare const DEFAULT_EMOTE_RADIUS = 20;
 export interface EmoteBroadcastResult {
@@ -94,6 +108,33 @@ export interface Emotes {
         reason: string;
     };
 }
+export interface WorldInviteTarget {
+    serverId: string;
+    joinCode?: string;
+}
+export interface WorldInvite extends WorldInviteTarget {
+    id: string;
+    fromUserId: string;
+    toUserId: string;
+    createdAt: number;
+}
+export interface WorldInvites {
+    canInvite(fromUserId: string, toUserId: string): {
+        reason: string;
+    } | null;
+    invite(fromUserId: string, toUserId: string, target: WorldInviteTarget): {
+        inviteId: string;
+    } | {
+        reason: string;
+    };
+    accept(userId: string, inviteId: string): {
+        target: WorldInviteTarget;
+    } | {
+        reason: string;
+    };
+    decline(userId: string, inviteId: string): void;
+    listFor(userId: string): WorldInvite[];
+}
 export interface Social {
     friends: Friends;
     party: Party;
@@ -101,5 +142,6 @@ export interface Social {
         get(userId: string): PresenceInfo;
     };
     emotes: Emotes;
+    worldInvites: WorldInvites;
 }
 export declare function createSocial(deps: SocialDeps): Social;