@series-inc/rundot-syncplay 6.0.0-rc.41 → 6.0.0-rc.43

package/README.md

@@ -31,6 +31,16 @@ The profiling entry keeps the named WASM file in the game build. Keep it out of
 release imports to exclude that file. The npm package still includes both
 artifacts. Profiling uses the same simulation source and digest rules.
 
+## Dynamic seat control & player-keyed secrets
+
+Syncplay supports deterministic dynamic seating across any valid simulation capacity X via `deterministic.seatPolicy`:
+- Transitions S1 through S6 govern empty, bot, and human controller states.
+- Policy fields include `recycleVacatedSeats`, `allowHumanClaimBot` (enabling human takeover of bot seats for S3), `onHumanLeave` (`'empty' | 'bot'`), and `initialBotSlots`. Retained owners can always reclaim their own seats without `allowHumanClaimBot`.
+- Controller leases are authority-issued and room-scoped (`claimId`, `botLeaseId`, `controlEpoch`).
+- Private secret holdings (cards, items, secret roles, and choices) are strictly bound to authenticated `playerId` and `claimId`.
+- Unconsumed holdings are permanently revoked when a human releases a recyclable seat (`recycleVacatedSeats: true`).
+- A successor player occupying a vacated seat never inherits prior items, secret values, or roles.
+
 ## Installation
 
 Install the RUN SDK and Syncplay in the game project. Syncplay uses the

package/core/src/physics/physics-profile-wasm-module.generated.mjs

@@ -23,7 +23,7 @@ export const physicsProfileWasmMetadata = Object.freeze({
   "sourceHash": "095061366ce3734601d06d48fa61d88a8538e1ba01e9c47663a7303ddb18fee7",
   "wasmSha256": "4b2ac3ff7d0f7a15eb31f5742a90f16f458a906d5d41bdc5fbde03e5589f94bf",
   "artifact": "profile",
-  "packageVersion": "6.0.0-rc.41",
+  "packageVersion": "6.0.0-rc.43",
   "compilerFlags": [
     "-std=c++20",
     "-O3",

package/core/src/physics/physics-wasm-module.generated.mjs

@@ -23,7 +23,7 @@ export const physicsWasmMetadata = Object.freeze({
   "sourceHash": "38d5f2cde9e8d448f029fd2921a743e4a40e19dc84c03abf7bed829003e2469d",
   "wasmSha256": "5f6a3d861cf3eb79a2f8060d6c4b5512673a943044a52a9d20b39f0f2fef985f",
   "artifact": "production",
-  "packageVersion": "6.0.0-rc.41",
+  "packageVersion": "6.0.0-rc.43",
   "compilerFlags": [
     "-std=c++20",
     "-O3",

package/core/src/physics2d/physics2d-wasm-module.generated.mjs

@@ -50,7 +50,7 @@ export const physics2dWasmMetadata = Object.freeze({
   "sourceHash": "faa090a03a6fddaf79c704fb1d76f810955ff35597449c8cec9541a75905a37e",
   "wasmSha256": "49cb90541deed40f5fff1015bb578e13ec9a793d51931c1227e3e5a11bbfa3f7",
   "artifact": "production",
-  "packageVersion": "6.0.0-rc.41",
+  "packageVersion": "6.0.0-rc.43",
   "compilerFlags": [
     "-std=c++20",
     "-O3",

package/dist/authority-room.d.ts

@@ -5,6 +5,8 @@ import type { SyncplayMatchLog } from './match-log.js';
 import { type SyncplaySecretAuthoritySnapshot } from './secret-authority.js';
 import type { SyncplaySecretAuthorityCrypto } from './secret-crypto.js';
 import type { SyncplaySecretSystemsConfig } from './secret-config.js';
+import { type SeatPolicy, type BotLease, type SeatCheckpoint } from './seat-control.js';
+export type { SeatPolicy, BotLease, SeatCheckpoint };
 /**
  * Transport-agnostic, game-agnostic deterministic authority room (§6 M2).
  *
@@ -122,6 +124,7 @@ export interface DeterministicAuthorityRoomConfig {
     readonly creatorSlot?: number;
     readonly eventKeyId?: string;
     readonly slotPolicies?: readonly AuthoritySlotPolicy[];
+    readonly seatPolicy?: SeatPolicy;
 }
 export interface DeterministicAuthorityRoomReconfiguration {
     readonly sessionConfigBytes: Uint8Array;
@@ -273,6 +276,7 @@ export interface DeterministicAuthorityRoomRestoreState {
     readonly sessionConfigBytes: Uint8Array;
     readonly sessionConfigDigest: string;
     readonly secretState?: SyncplaySecretAuthoritySnapshot;
+    readonly seatCheckpoint?: SeatCheckpoint;
     /** Session generation at persist time; a restored room re-greets with it. Default 0. */
     readonly generation?: number;
     readonly membershipEpoch?: number;
@@ -352,7 +356,7 @@ export interface AuthorityRoomNetcodeStats {
 export interface AuthorityRoomJoinResult {
     readonly accepted: boolean;
     readonly slot?: number;
-    readonly reason?: 'room-full' | 'already-joined' | 'history-unavailable' | 'incompatible-protocol';
+    readonly reason?: 'room-full' | 'already-joined' | 'history-unavailable' | 'incompatible-protocol' | 'seat-reassigned' | 'seat-unavailable';
     /** True when this join re-attached a previously-seen playerId to its original slot. */
     readonly rejoined?: boolean;
 }
@@ -379,6 +383,7 @@ export interface AuthorityRoomSnapshot {
     readonly latestSnapshot?: AuthorityRoomStoredSnapshotMeta;
     /** Most recent snapshot rejection reason, if any snapshot attempt was rejected. */
     readonly lastSnapshotRejection?: string;
+    readonly seatCheckpoint?: SeatCheckpoint;
     /** Details of the pending snapshot transfer currently in-flight, if any. */
     readonly membershipEpoch?: number;
     readonly memberships?: readonly TickMembership[];
@@ -498,8 +503,8 @@ export interface DeterministicAuthorityRoom {
         readonly keyId?: string;
     }): EventQueueResult;
     receiveVirtualInput(validated: BotInputSubmission): InputSubmissionResult;
-    activateBotSlot(slot: number, botId?: string): void;
-    deactivateBotSlot(slot: number): void;
+    activateBotSlot(slot: number, botId?: string): BotLease | void;
+    deactivateBotSlot(slot: number, leaseId?: string): void;
     evacuateParticipant(slot: number, scheduledTick?: number): {
         scheduledTick: number;
     };

package/dist/authority-room.js

@@ -6,6 +6,7 @@ import { createDeterministicLocalAuthoritySnapshotChunkEnvelope, createDetermini
 import { DEFAULT_SNAPSHOT_CHUNK_SIZE, createSnapshotTransferCollector, createSnapshotTransferFromBytes, decodeDeterministicStateSnapshot, encodeDeterministicStateSnapshot, deterministicRoomDescriptorHash, } from './session-snapshot.js';
 import { MAX_KINETIX_SESSION_CONFIG_BYTES, MAX_SYNCPLAY_COMMAND_PAYLOAD_BYTES, MAX_SYNCPLAY_EPHEMERAL_PAYLOAD_BYTES, decodeDeterministicSessionMessage, encodeDeterministicSessionMessage, } from './session-wire.js';
 import { createSyncplaySecretAuthority, } from './secret-authority.js';
+import { DEFAULT_SEAT_POLICY, validateSeatPolicy, createInitialSeatControlState, allocatable, findAvailableSeat, applyTransition, createSeatCheckpoint, restoreSeatControlState, } from './seat-control.js';
 const DEFAULT_SESSION_MSG_TYPE = 'rdm';
 const DEFAULT_SECRET_MSG_TYPE = 'rdm-secret';
 /** One hour at 60 Hz — see DeterministicAuthorityRoomConfig.historyRetentionTicks. */
@@ -83,6 +84,50 @@ export function createDeterministicAuthorityRoom(transport, config) {
     const botSlotSet = new Set(config.slotPolicies?.filter((p) => p.control.kind === 'bot').map((p) => p.slot) ?? []);
     const activeBotSlots = new Set();
     const lastBotSequenceBySlot = new Map();
+    const seatPolicy = config.seatPolicy !== undefined
+        ? validateSeatPolicy(config.seatPolicy, config.playerCount)
+        : undefined;
+    const activeBotLeaseBySlot = new Map();
+    const lastBotSequenceByLease = new Map();
+    const claimAttributions = [];
+    let pendingTransitions = [];
+    let seatControlState = config.restoreFrom?.seatCheckpoint !== undefined
+        ? restoreSeatControlState(config.restoreFrom.seatCheckpoint)
+        : createInitialSeatControlState(config.playerCount, seatPolicy ?? DEFAULT_SEAT_POLICY, config.seatPolicy === undefined ? { legacyBotSlots: [...botSlotSet] } : undefined);
+    let hasStartedLobby = false;
+    if (config.restoreFrom?.seatCheckpoint !== undefined) {
+        for (let slot = 0; slot < config.playerCount; slot++) {
+            const seat = seatControlState.seats[slot];
+            if (seat.control.kind === "bot") {
+                activeBotSlots.add(slot);
+                const lease = {
+                    roomId: config.authorityId ?? "room",
+                    authorityEpoch: config.authorityEpoch ?? 0,
+                    slot,
+                    controlEpoch: seat.control.controlEpoch,
+                    leaseId: seat.control.botLeaseId,
+                    controllerId: seat.control.controllerId,
+                };
+                activeBotLeaseBySlot.set(slot, lease);
+                lastBotSequenceByLease.set(lease.leaseId, 0);
+            }
+        }
+    }
+    else if (seatPolicy !== undefined) {
+        for (const s of seatPolicy.initialBotSlots) {
+            activeBotSlots.add(s);
+            const initialLease = {
+                roomId: config.authorityId ?? "room",
+                authorityEpoch: config.authorityEpoch ?? 0,
+                slot: s,
+                controlEpoch: 0,
+                leaseId: `lease-${s}-0`,
+                controllerId: `bot-${s}`,
+            };
+            activeBotLeaseBySlot.set(s, initialLease);
+            lastBotSequenceByLease.set(initialLease.leaseId, 0);
+        }
+    }
     let nextAuthorityEventSequence = config.restoreFrom?.nextAuthorityEventSequence ?? 1;
     const enqueuedEventsById = new Map();
     if (config.restoreFrom?.enqueuedEvents) {
@@ -187,6 +232,9 @@ export function createDeterministicAuthorityRoom(transport, config) {
         }
     }
     function isSlotReserved(slot, playerId) {
+        if (config.seatPolicy !== undefined) {
+            return !allocatable(seatControlState, playerId, slot);
+        }
         for (const [pId, s] of everSlotByPlayer.entries()) {
             if (s === slot && pId !== playerId)
                 return true;
@@ -371,6 +419,12 @@ export function createDeterministicAuthorityRoom(transport, config) {
             // Omitted at generation 0 so a room that never reconfigures encodes
             // byte-identically to what pre-generation peers expect.
             ...(generation === 0 ? {} : { generation }),
+            ...(config.seatPolicy !== undefined && slot >= 0 && slot < config.playerCount && seatControlState.seats[slot].control.kind === "human"
+                ? {
+                    claimId: seatControlState.seats[slot].control.claimId,
+                    controlEpoch: seatControlState.seats[slot].control.controlEpoch,
+                }
+                : {}),
         }));
     }
     /**
@@ -478,6 +532,79 @@ export function createDeterministicAuthorityRoom(transport, config) {
                 return { accepted: false, reason: 'incompatible-protocol' };
             }
         }
+        if (config.seatPolicy !== undefined) {
+            if (seatControlState.rejoinRecords.some((r) => r.playerId === playerId && r.replacedByHuman)) {
+                transport.sendTo(playerId, sessionMsgType, encodeDeterministicSessionMessage({
+                    kind: "error",
+                    code: "seat-reassigned",
+                    message: "Seat has been reassigned to another participant",
+                }));
+                return { accepted: false, reason: "seat-reassigned" };
+            }
+            if (slotByPlayer.has(playerId)) {
+                if (options?.isPending !== undefined) {
+                    setPlayerPending(playerId, options.isPending);
+                }
+                return { accepted: false, reason: "already-joined" };
+            }
+            const alloc = findAvailableSeat(seatControlState, playerId);
+            if (!alloc.ok) {
+                return { accepted: false, reason: alloc.reason === "seat-reassigned" ? "seat-reassigned" : "room-full" };
+            }
+            const plan = catchUpPlan();
+            if (plan === "unavailable") {
+                return { accepted: false, reason: "history-unavailable" };
+            }
+            const slot = alloc.slot;
+            const currentSeat = seatControlState.seats[slot];
+            const kind = currentSeat.control.kind === "bot" ? "S3_bot_to_human" : "S2_empty_to_human";
+            const claimId = alloc.resumedClaim && currentSeat.retainedClaim
+                ? currentSeat.retainedClaim.claimId
+                : `claim-${playerId}-${now + 1}-${membershipEpoch}`;
+            const intent = {
+                eventId: `join-${playerId}-${now + 1}`,
+                kind,
+                slot,
+                effectiveTick: Math.max(0, now + 1),
+                expectedEpoch: currentSeat.control.controlEpoch,
+                playerId,
+                claimId,
+            };
+            const res = applyTransition(seatControlState, intent);
+            seatControlState = res.nextState;
+            if (res.effects.revokedBotLeaseId) {
+                activeBotLeaseBySlot.delete(slot);
+                activeBotSlots.delete(slot);
+            }
+            slotByPlayer.set(playerId, slot);
+            everSlotByPlayer.set(playerId, slot);
+            assignedSlots = Math.max(assignedSlots, slot + 1);
+            membershipEpoch += 1;
+            disconnectedPlayers.delete(playerId);
+            if (options?.isPending === true) {
+                pendingPlayers.add(playerId);
+            }
+            else {
+                pendingPlayers.delete(playerId);
+            }
+            claimAttributions.push({
+                slot,
+                playerId,
+                claimId,
+                startTick: Math.max(0, authority.confirmedThrough + 1),
+            });
+            sendSessionStart(playerId, slot);
+            if (alloc.resumedClaim) {
+                secretAuthority?.onPlayerReconnected(playerId, slot, claimId);
+                sendCatchUpTo(playerId, plan, "rejoin");
+                return { accepted: true, slot, rejoined: true };
+            }
+            else {
+                secretAuthority?.onPlayerJoined(playerId, slot, claimId);
+                sendCatchUpTo(playerId, plan, "join");
+                return { accepted: true, slot };
+            }
+        }
         const existing = slotByPlayer.get(playerId);
         if (existing !== undefined) {
             if (options?.isPending !== undefined) {
@@ -783,6 +910,7 @@ export function createDeterministicAuthorityRoom(transport, config) {
         for (const seat of admission.seats) {
             pendingPlayers.delete(seat.playerId);
             if (slotByPlayer.get(seat.playerId) === seat.slot) {
+                secretAuthority?.onPlayerLeft(seat.playerId, seat.slot, { releaseMode: "retain" });
                 slotByPlayer.delete(seat.playerId);
             }
             // Note: do not delete from everSlotByPlayer so the fixed roster preserves seat ownership
@@ -1046,6 +1174,14 @@ export function createDeterministicAuthorityRoom(transport, config) {
         });
     }
     function reconfigureSession(next) {
+        const hasPendingTransitions = pendingTransitions.length > 0;
+        const hasUnappliedStaged = [...stagedAdmissions.values()].some((a) => !appliedAdmissionIds.has(a.admissionId));
+        const hasScheduledEvacuations = scheduledEvacuations.size > 0;
+        const hasScheduledAdmissions = scheduledAdmissions.size > 0;
+        const isSecretBusy = secretAuthority?.isBusy ? secretAuthority.isBusy() : false;
+        if (hasPendingTransitions || hasUnappliedStaged || hasScheduledEvacuations || hasScheduledAdmissions || isSecretBusy) {
+            throw new Error('seat-reset-busy');
+        }
         if (next.runtimeIdentity !== undefined && !equalRuntimeIdentity(next.runtimeIdentity, config.runtimeIdentity)) {
             throw new Error('SYNCPLAY_RECONFIGURE_IDENTITY_MISMATCH');
         }
@@ -1087,6 +1223,52 @@ export function createDeterministicAuthorityRoom(transport, config) {
             if (!slotByPlayer.has(id))
                 disconnectedPlayers.delete(id);
         }
+        if (config.seatPolicy !== undefined) {
+            lastBotSequenceByLease.clear();
+            for (let slot = 0; slot < config.playerCount; slot++) {
+                const seat = seatControlState.seats[slot];
+                if (seat.control.kind === "human") {
+                    const nextEpoch = seat.control.controlEpoch + 1;
+                    const updatedSeat = {
+                        ...seat,
+                        control: {
+                            ...seat.control,
+                            controlEpoch: nextEpoch,
+                        },
+                    };
+                    seatControlState = {
+                        ...seatControlState,
+                        seats: seatControlState.seats.map((s, idx) => (idx === slot ? updatedSeat : s)),
+                    };
+                }
+                else if (seat.control.kind === "bot") {
+                    const nextEpoch = seat.control.controlEpoch + 1;
+                    const botLeaseId = `lease-${slot}-${nextEpoch}`;
+                    const updatedSeat = {
+                        ...seat,
+                        control: {
+                            ...seat.control,
+                            controlEpoch: nextEpoch,
+                            botLeaseId,
+                        },
+                    };
+                    seatControlState = {
+                        ...seatControlState,
+                        seats: seatControlState.seats.map((s, idx) => (idx === slot ? updatedSeat : s)),
+                    };
+                    const newLease = {
+                        roomId: config.authorityId ?? "room",
+                        authorityEpoch: config.authorityEpoch ?? 0,
+                        slot,
+                        controlEpoch: nextEpoch,
+                        leaseId: botLeaseId,
+                        controllerId: seat.control.controllerId,
+                    };
+                    activeBotLeaseBySlot.set(slot, newLease);
+                    lastBotSequenceByLease.set(botLeaseId, 0);
+                }
+            }
+        }
         membershipEpoch += 1;
         reportsDirty = false;
         substitutedTicksBySlot.clear();
@@ -1391,6 +1573,69 @@ export function createDeterministicAuthorityRoom(transport, config) {
             pendingPlayers.delete(playerId);
         }
         membershipEpoch += 1;
+        if (config.seatPolicy !== undefined) {
+            const slot = slotByPlayer.get(playerId);
+            if (slot === undefined)
+                return;
+            const currentSeat = seatControlState.seats[slot];
+            if (currentSeat.control.kind !== "human")
+                return;
+            const kind = seatPolicy.onHumanLeave === "bot" ? "S5_human_to_bot" : "S6_human_to_empty";
+            const effectiveTick = Math.max(0, now + 1);
+            const nextEpoch = currentSeat.control.controlEpoch + 1;
+            const botLeaseId = `lease-${slot}-${nextEpoch}`;
+            const intent = {
+                eventId: `leave-${playerId}-${effectiveTick}`,
+                kind,
+                slot,
+                effectiveTick,
+                expectedEpoch: currentSeat.control.controlEpoch,
+                playerId,
+                controllerId: `bot-${slot}`,
+                botLeaseId,
+                reason: "final-leave",
+            };
+            const res = applyTransition(seatControlState, intent);
+            seatControlState = res.nextState;
+            if (res.effects.secretRelease) {
+                secretAuthority?.onPlayerLeft(res.effects.secretRelease.playerId, res.effects.secretRelease.slot, {
+                    releaseMode: res.effects.secretRelease.releaseMode,
+                    reason: "leave",
+                });
+            }
+            for (let i = claimAttributions.length - 1; i >= 0; i--) {
+                const attr = claimAttributions[i];
+                if (attr.playerId === playerId && attr.endTick === undefined) {
+                    claimAttributions[i] = {
+                        ...attr,
+                        endTick: effectiveTick,
+                    };
+                    break;
+                }
+            }
+            authority.neutralizeSlotFrom(slot, effectiveTick);
+            slotByPlayer.delete(playerId);
+            if (seatPolicy.recycleVacatedSeats) {
+                everSlotByPlayer.delete(playerId);
+            }
+            if (seatPolicy.onHumanLeave === "bot") {
+                activeBotSlots.add(slot);
+                const newLease = {
+                    roomId: config.authorityId ?? "room",
+                    authorityEpoch: config.authorityEpoch ?? 0,
+                    slot,
+                    controlEpoch: nextEpoch,
+                    leaseId: botLeaseId,
+                    controllerId: `bot-${slot}`,
+                };
+                activeBotLeaseBySlot.set(slot, newLease);
+                lastBotSequenceByLease.set(botLeaseId, 0);
+            }
+            if (pendingTransfer?.donorId === playerId) {
+                failPendingTransfer("snapshot-donor-left");
+            }
+            return;
+        }
         // Fixed roster for v1 (late-join/reconnect is M5). Dropping the mapping stops accepting the
         // departed player's input; their slot stays reserved because `assignedSlots` never decreases,
         // so the authority substitutes for it rather than handing the number to a new joiner.
@@ -1412,8 +1657,18 @@ export function createDeterministicAuthorityRoom(transport, config) {
         // drop-in: the clock runs from the first join and later players catch up
         // via the history replay in onPlayerJoin. `assignedSlots` is monotonic, so
         // a mid-match leave never re-pauses a started room.
-        if (config.waitForFullRoom === true && assignedSlots < config.playerCount) {
-            return;
+        if (config.waitForFullRoom === true && !hasStartedLobby) {
+            if (config.seatPolicy !== undefined) {
+                const activeCount = seatControlState.seats.filter((s) => s.control.kind === "human" || s.control.kind === "bot").length;
+                if (activeCount < config.playerCount)
+                    return;
+                hasStartedLobby = true;
+            }
+            else {
+                if (assignedSlots < config.playerCount)
+                    return;
+                hasStartedLobby = true;
+            }
         }
         now += 1;
         for (const [schedTick, slots] of scheduledEvacuations.entries()) {
@@ -1427,8 +1682,89 @@ export function createDeterministicAuthorityRoom(transport, config) {
                             break;
                         }
                     }
+                    if (config.seatPolicy !== undefined) {
+                        const currentSeat = seatControlState.seats[slot];
+                        if (currentSeat && currentSeat.control.kind === "human") {
+                            const departingPlayerId = currentSeat.control.playerId;
+                            const kind = "S6_human_to_empty";
+                            const nextEpoch = currentSeat.control.controlEpoch + 1;
+                            const intent = {
+                                eventId: `evacuate-${departingPlayerId}-${now}`,
+                                kind,
+                                slot,
+                                effectiveTick: now,
+                                expectedEpoch: currentSeat.control.controlEpoch,
+                                playerId: departingPlayerId,
+                                reason: "evacuation",
+                            };
+                            const res = applyTransition(seatControlState, intent);
+                            seatControlState = res.nextState;
+                            if (res.effects.secretRelease) {
+                                secretAuthority?.onPlayerLeft(res.effects.secretRelease.playerId, res.effects.secretRelease.slot, {
+                                    releaseMode: res.effects.secretRelease.releaseMode,
+                                    reason: "evacuation",
+                                });
+                            }
+                            for (let i = claimAttributions.length - 1; i >= 0; i--) {
+                                const attr = claimAttributions[i];
+                                if (attr.playerId === departingPlayerId && attr.endTick === undefined) {
+                                    claimAttributions[i] = {
+                                        ...attr,
+                                        endTick: now,
+                                    };
+                                    break;
+                                }
+                            }
+                            authority.neutralizeSlotFrom(slot, now);
+                        }
+                        else if (currentSeat && currentSeat.control.kind === "bot") {
+                            const intent = {
+                                eventId: `evacuate-bot-${slot}-${now}`,
+                                kind: "S4_bot_to_empty",
+                                slot,
+                                effectiveTick: now,
+                                expectedEpoch: currentSeat.control.controlEpoch,
+                                botLeaseId: currentSeat.control.botLeaseId,
+                                reason: "evacuation",
+                            };
+                            const res = applyTransition(seatControlState, intent);
+                            seatControlState = res.nextState;
+                            if (res.effects.revokedBotLeaseId) {
+                                activeBotLeaseBySlot.delete(slot);
+                                activeBotSlots.delete(slot);
+                            }
+                            if (res.effects.secretRelease) {
+                                secretAuthority?.onPlayerLeft(res.effects.secretRelease.playerId, res.effects.secretRelease.slot, {
+                                    releaseMode: res.effects.secretRelease.releaseMode,
+                                    reason: "evacuation",
+                                });
+                            }
+                            authority.neutralizeSlotFrom(slot, now);
+                        }
+                        else if (currentSeat) {
+                            const nextEvac = new Set(seatControlState.evacuatedSlots);
+                            nextEvac.add(slot);
+                            const nextRejoins = seatControlState.rejoinRecords.map((r) => {
+                                if (r.formerSlot === slot) {
+                                    return { ...r, replacedByHuman: true };
+                                }
+                                return r;
+                            });
+                            seatControlState = {
+                                ...seatControlState,
+                                evacuatedSlots: nextEvac,
+                                rejoinRecords: nextRejoins,
+                            };
+                        }
+                    }
                     if (seatedPlayerId) {
                         evacuatedPlayerIds.add(seatedPlayerId);
+                        if (config.seatPolicy === undefined) {
+                            secretAuthority?.onPlayerLeft(seatedPlayerId, slot, {
+                                releaseMode: "retire",
+                                reason: "evacuation",
+                            });
+                        }
                         slotByPlayer.delete(seatedPlayerId);
                         membershipEpoch += 1;
                         transport.broadcast(sessionMsgType, encodeDeterministicSessionMessage({
@@ -1689,12 +2025,24 @@ export function createDeterministicAuthorityRoom(transport, config) {
         if (config.authorityEpoch !== undefined && validated.authorityEpoch !== config.authorityEpoch) {
             return { accepted: false, reason: 'invalid-tick' };
         }
-        if (!botSlotSet.has(validated.slot)) {
-            return { accepted: false, reason: 'slot-out-of-range' };
+        if (config.seatPolicy !== undefined) {
+            const currentLease = activeBotLeaseBySlot.get(validated.slot);
+            if (!currentLease || validated.botLeaseId !== currentLease.leaseId) {
+                return { accepted: false, reason: 'slot-out-of-range' };
+            }
+            const lastSeq = lastBotSequenceByLease.get(currentLease.leaseId) ?? 0;
+            if (validated.sequence <= lastSeq) {
+                return { accepted: false, reason: 'invalid-tick' };
+            }
         }
-        const lastSeq = lastBotSequenceBySlot.get(validated.slot);
-        if (lastSeq !== undefined && validated.sequence <= lastSeq) {
-            return { accepted: false, reason: 'invalid-tick' };
+        else {
+            if (!botSlotSet.has(validated.slot)) {
+                return { accepted: false, reason: 'slot-out-of-range' };
+            }
+            const lastSeq = lastBotSequenceBySlot.get(validated.slot);
+            if (lastSeq !== undefined && validated.sequence <= lastSeq) {
+                return { accepted: false, reason: 'invalid-tick' };
+            }
         }
         if (validated.tick <= authority.confirmedThrough) {
             return { accepted: false, reason: 'tick-already-confirmed' };
@@ -1704,20 +2052,94 @@ export function createDeterministicAuthorityRoom(transport, config) {
         }
         const result = authority.receiveInput(validated.slot, validated.tick, validated.input);
         if (result.accepted) {
-            lastBotSequenceBySlot.set(validated.slot, validated.sequence);
+            if (config.seatPolicy !== undefined) {
+                const currentLease = activeBotLeaseBySlot.get(validated.slot);
+                if (currentLease) {
+                    lastBotSequenceByLease.set(currentLease.leaseId, validated.sequence);
+                }
+            }
+            else {
+                lastBotSequenceBySlot.set(validated.slot, validated.sequence);
+            }
         }
         return result;
     }
     function activateBotSlot(slot, botId) {
-        if (!botSlotSet.has(slot))
+        if (slot < 0 || slot >= config.playerCount)
+            return;
+        if (config.seatPolicy === undefined) {
+            if (!botSlotSet.has(slot))
+                return;
+            activeBotSlots.add(slot);
+            if (botId)
+                bots.add(botId);
             return;
+        }
+        const seat = seatControlState.seats[slot];
+        if (seat.control.kind === "bot") {
+            const lease = activeBotLeaseBySlot.get(slot);
+            if (lease)
+                return lease;
+        }
+        const controllerId = botId ?? `bot-${slot}`;
+        const nextEpoch = seat.control.controlEpoch + 1;
+        const botLeaseId = `lease-${slot}-${nextEpoch}`;
+        const lease = {
+            roomId: config.authorityId ?? "room",
+            authorityEpoch: config.authorityEpoch ?? 0,
+            slot,
+            controlEpoch: nextEpoch,
+            leaseId: botLeaseId,
+            controllerId,
+        };
+        const intent = {
+            eventId: `act-bot-${slot}-${nextEpoch}`,
+            kind: "S1_empty_to_bot",
+            slot,
+            effectiveTick: Math.max(0, now + 1),
+            expectedEpoch: seat.control.controlEpoch,
+            controllerId,
+            botLeaseId,
+        };
+        const res = applyTransition(seatControlState, intent);
+        seatControlState = res.nextState;
         activeBotSlots.add(slot);
+        activeBotLeaseBySlot.set(slot, lease);
+        lastBotSequenceByLease.set(botLeaseId, 0);
         if (botId)
             bots.add(botId);
+        return lease;
     }
-    function deactivateBotSlot(slot) {
+    function deactivateBotSlot(slot, leaseId) {
+        if (slot < 0 || slot >= config.playerCount)
+            return;
+        if (config.seatPolicy === undefined) {
+            activeBotSlots.delete(slot);
+            authority.neutralizeSlot(slot);
+            return;
+        }
+        const currentLease = activeBotLeaseBySlot.get(slot);
+        if (leaseId !== undefined && currentLease && currentLease.leaseId !== leaseId) {
+            return;
+        }
+        const seat = seatControlState.seats[slot];
+        if (seat.control.kind !== "bot")
+            return;
+        const nextEpoch = seat.control.controlEpoch + 1;
+        const effectiveTick = Math.max(0, now + 1);
+        const intent = {
+            eventId: `deact-bot-${slot}-${nextEpoch}`,
+            kind: "S4_bot_to_empty",
+            slot,
+            effectiveTick,
+            expectedEpoch: seat.control.controlEpoch,
+            botLeaseId: seat.control.botLeaseId,
+        };
+        const res = applyTransition(seatControlState, intent);
+        seatControlState = res.nextState;
+        authority.neutralizeSlotFrom(slot, effectiveTick);
         activeBotSlots.delete(slot);
-        authority.neutralizeSlot(slot);
+        activeBotLeaseBySlot.delete(slot);
     }
     return {
         get confirmedThrough() {
@@ -1783,6 +2205,7 @@ export function createDeterministicAuthorityRoom(transport, config) {
                 sessionConfigDigest,
                 generation,
                 ...(lastSnapshotRejection === undefined ? {} : { lastSnapshotRejection }),
+                ...(seatPolicy !== undefined ? { seatCheckpoint: createSeatCheckpoint(seatControlState) } : {}),
                 ...(pendingTransfer === undefined
                     ? {}
                     : {
@@ -1841,6 +2264,19 @@ export function createDeterministicAuthorityRoom(transport, config) {
             if (authority.confirmedThrough < 0 || !historyReachesTickZero()) {
                 return undefined;
             }
+            if (config.seatPolicy !== undefined) {
+                return {
+                    v: 2,
+                    seed,
+                    tickRateHz: config.tickRateHz,
+                    playerCount: config.playerCount,
+                    hardToleranceTicks: config.hardToleranceTicks,
+                    confirmedThrough: authority.confirmedThrough,
+                    everSlots: Object.fromEntries(everSlotByPlayer),
+                    claimAttributions: claimAttributions.map((ca) => ({ ...ca })),
+                    frames: authority.confirmedFrameRange(0, authority.confirmedThrough),
+                };
+            }
             return {
                 v: 1,
                 seed,