@zhin.js/plugin-roulette 0.0.0-stage → 0.1.2

package/lib/game-flow.js

@@ -0,0 +1,226 @@
+import { GameSessionConflictError, SessionRevisionConflictError, channelKey, } from '@zhin.js/game-kit';
+import { RouletteRuleError, loserOf } from './engine.js';
+import { ROULETTE_HELP } from './roulette-actions.js';
+import { playerFromMessage, stateOf, } from './session-service.js';
+import { describeAbort, describeClick, describeEnding, describeLobby, describeRoundStart, describeStatus, } from './view.js';
+const DEADLINE_ACTOR = 'deadline';
+const MANAGER_ROLES = ['master', 'trusted', 'owner', 'admin'];
+const NO_GAME_TEXT = '本群没有进行中的轮盘，发送「轮盘 开局」创建一局。';
+export async function runRouletteAction(flow, actor, action) {
+    const message = actor.message;
+    if (action === 'help')
+        return ROULETTE_HELP;
+    if (message.$channel.type === 'private')
+        return '轮盘需要多人参与，请在群聊里玩。';
+    if (action === 'penalty-on' || action === 'penalty-off' || action === 'penalty-status') {
+        return handlePenaltySetting(flow, actor, action);
+    }
+    const notices = [];
+    let session = await flow.services.sessions.getActiveByChannel(channelKey(message));
+    if (session && isOverdue(session, Date.now())) {
+        const expired = await expireSession(flow, session);
+        if (expired)
+            notices.push(expired);
+        session = null;
+    }
+    const reply = await handleGameAction(flow, actor, action, session);
+    return [...notices, reply].join('\n\n');
+}
+/** Called by the deadline schedule; each returned notice still has to be delivered. */
+export async function expireOverdueSessions(flow, now, onNotice) {
+    const overdue = await flow.services.sessions.listOverdue(now);
+    const notices = [];
+    for (const session of overdue) {
+        try {
+            const text = await expireSession(flow, session);
+            if (!text)
+                continue;
+            const notice = { session, text };
+            notices.push(notice);
+            // Announce as soon as the result is stored, so a later failure cannot drop it.
+            if (onNotice)
+                await onNotice(notice);
+        }
+        catch (error) {
+            // The session stays active when anything before the commit failed; the next sweep retries it.
+            const reason = error instanceof Error ? error.message : String(error);
+            console.warn(`[roulette] 处理超时对局 ${session.id} 失败，下次扫描重试：${reason}`);
+        }
+    }
+    return notices;
+}
+async function handleGameAction(flow, actor, action, session) {
+    const message = actor.message;
+    if (action === 'open')
+        return openLobby(flow, actor, session);
+    if (!session)
+        return NO_GAME_TEXT;
+    if (action === 'status')
+        return describeStatus(stateOf(session), flow.config);
+    if (action === 'cancel' && !mayCancel(session, message, actor.roles)) {
+        return '只有开局的人、群主、群管理员或机器人管理员可以取消本局。';
+    }
+    const gameAction = toGameAction(action, message);
+    if (!gameAction)
+        return NO_GAME_TEXT;
+    try {
+        const result = await flow.services.sessions.applyAction(session, message.$sender.id, gameAction, flow.config);
+        return describeResult(flow, gameAction, result, message);
+    }
+    catch (error) {
+        if (error instanceof RouletteRuleError)
+            return error.message;
+        if (error instanceof GameSessionConflictError)
+            return error.message;
+        if (error instanceof SessionRevisionConflictError)
+            return '对局状态刚刚变了，请再发一次。';
+        throw error;
+    }
+}
+async function openLobby(flow, actor, session) {
+    if (session) {
+        return `本群已经有一局轮盘了。\n${describeStatus(stateOf(session), flow.config)}`;
+    }
+    try {
+        const created = await flow.services.sessions.createLobby(actor.message, actor.endpoint, flow.config);
+        return describeLobby(stateOf(created), flow.config);
+    }
+    catch (error) {
+        if (error instanceof GameSessionConflictError)
+            return error.message;
+        throw error;
+    }
+}
+async function describeResult(flow, action, result, message) {
+    const state = result.state;
+    if (!result.applied)
+        return describeStatus(state, flow.config);
+    if (state.phase === 'finished')
+        return finishText(flow, result.session, state);
+    if (state.phase === 'aborted')
+        return describeAbort(state);
+    if (action.type === 'start')
+        return describeRoundStart(state, flow.config);
+    if (action.type === 'fire') {
+        return describeClick(playerFromMessage(message), state, flow.config);
+    }
+    if (action.type === 'leave') {
+        return `${playerFromMessage(message).name} 离开了。\n${describeLobby(state, flow.config)}`;
+    }
+    return describeLobby(state, flow.config);
+}
+async function expireSession(flow, session) {
+    // Read everything that can fail before the state transition is committed: once the
+    // session is stored as finished it is no longer overdue and would never be retried.
+    const penaltyEnabled = stateOf(session).phase === 'playing'
+        ? await flow.services.settings.isMutePenaltyEnabled(session.channel_key)
+        : false;
+    try {
+        const result = await flow.services.sessions.applyAction(session, DEADLINE_ACTOR, { type: 'expire' }, flow.config);
+        if (!result.applied)
+            return '';
+        if (result.state.phase === 'finished')
+            return finishText(flow, result.session, result.state, penaltyEnabled);
+        return describeAbort(result.state);
+    }
+    catch (error) {
+        // A player acted on the session in the meantime; the next sweep re-reads it.
+        if (error instanceof SessionRevisionConflictError)
+            return '';
+        throw error;
+    }
+}
+async function finishText(flow, session, state, penaltyEnabled) {
+    const penalty = await applyLoserPenalty(flow, session, state, penaltyEnabled);
+    return [describeEnding(state), penalty].filter(Boolean).join('\n');
+}
+/** Mute the loser only when this group opted in and the Endpoint declares muting. */
+async function applyLoserPenalty(flow, session, state, penaltyEnabled) {
+    const loser = loserOf(state);
+    if (!loser)
+        return '';
+    const enabled = penaltyEnabled
+        ?? await flow.services.settings.isMutePenaltyEnabled(session.channel_key);
+    if (!enabled)
+        return '';
+    const conversation = conversationOfSession(session);
+    if (flow.penalty.support(conversation) !== 'supported') {
+        return '（本群开启了禁言惩罚，但当前平台无法禁言，本局只计分。）';
+    }
+    try {
+        await flow.penalty.mute(conversation, loser.id, flow.config.muteSeconds);
+        return `🔇 ${loser.name} 被禁言 ${flow.config.muteSeconds} 秒。`;
+    }
+    catch {
+        return '（禁言没有成功，可能是机器人没有群管理权限；本局只计分。）';
+    }
+}
+async function handlePenaltySetting(flow, actor, action) {
+    const message = actor.message;
+    if (message.$channel.type !== 'group')
+        return '禁言惩罚只能在群聊里设置。';
+    const key = channelKey(message);
+    const settings = flow.services.settings;
+    const support = flow.penalty.support(conversationOfActor(actor));
+    if (action === 'penalty-status') {
+        const enabled = await settings.isMutePenaltyEnabled(key);
+        return describePenaltyStatus(enabled, support === 'supported', flow.config);
+    }
+    if (!isManager(actor.roles))
+        return '只有群主、群管理员、机器人主人或受信任用户可以修改禁言惩罚。';
+    if (action === 'penalty-off') {
+        await settings.setMutePenalty(key, false, message.$sender.id);
+        return '已关闭禁言惩罚，本群轮盘只计分。';
+    }
+    if (support !== 'supported') {
+        return '当前平台不支持禁言，禁言惩罚没有开启；本群轮盘只计分。';
+    }
+    await settings.setMutePenalty(key, true, message.$sender.id);
+    return `已开启禁言惩罚：每局输家会被禁言 ${flow.config.muteSeconds} 秒（需要机器人有群管理权限）。`;
+}
+function describePenaltyStatus(enabled, supported, config) {
+    const platform = supported ? '当前平台支持禁言。' : '当前平台不支持禁言，只能计分。';
+    if (!enabled)
+        return `本群禁言惩罚：关闭。${platform}`;
+    return `本群禁言惩罚：开启，输家禁言 ${config.muteSeconds} 秒。${platform}`;
+}
+function toGameAction(action, message) {
+    if (action === 'join')
+        return { type: 'join', player: playerFromMessage(message) };
+    if (action === 'start')
+        return { type: 'start' };
+    if (action === 'fire')
+        return { type: 'fire' };
+    if (action === 'leave')
+        return { type: 'leave' };
+    if (action === 'cancel')
+        return { type: 'cancel' };
+    return null;
+}
+function mayCancel(session, message, senderRoles) {
+    if (stateOf(session).hostId === message.$sender.id)
+        return true;
+    return isManager(senderRoles);
+}
+function isManager(senderRoles) {
+    return senderRoles.some((role) => MANAGER_ROLES.includes(role));
+}
+function isOverdue(session, now) {
+    return session.deadline_at > 0 && session.deadline_at <= now;
+}
+export function conversationOfSession(session) {
+    return {
+        endpointAdapter: session.endpoint_adapter,
+        endpointId: session.endpoint_id,
+        kind: session.channel_type,
+        id: session.channel_id,
+    };
+}
+function conversationOfActor(actor) {
+    return {
+        endpointAdapter: actor.endpoint.adapter,
+        endpointId: actor.endpoint.id,
+        kind: actor.message.$channel.type,
+        id: actor.message.$channel.id,
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+export { DEFAULT_ROULETTE_CONFIG, resolveRouletteConfig, type RouletteConfig } from './config.js';
+export * from './engine.js';
+export { expireOverdueSessions, runRouletteAction, type RouletteActor, type RouletteFlow } from './game-flow.js';
+export { DEADLINE_CRON, runDeadlineSweep } from './deadline-job.js';
+export { resolveMutePenalty, type AdapterProjectionContext, type MutePenaltyPort, type MuteSupport, type PenaltyConversation, } from './mute-penalty.js';
+export { ROULETTE_HELP, normalizeRouletteAction, type RouletteCommandAction } from './roulette-actions.js';
+export { endpointOf, rouletteServicesToken, resolveRouletteFlow } from './runtime.js';
+export { RouletteGroupSettings, RouletteSessionService, createServices, type EndpointIdentity, type RouletteServices, } from './session-service.js';

package/lib/index.js

@@ -0,0 +1,8 @@
+export { DEFAULT_ROULETTE_CONFIG, resolveRouletteConfig } from './config.js';
+export * from './engine.js';
+export { expireOverdueSessions, runRouletteAction } from './game-flow.js';
+export { DEADLINE_CRON, runDeadlineSweep } from './deadline-job.js';
+export { resolveMutePenalty, } from './mute-penalty.js';
+export { ROULETTE_HELP, normalizeRouletteAction } from './roulette-actions.js';
+export { endpointOf, rouletteServicesToken, resolveRouletteFlow } from './runtime.js';
+export { RouletteGroupSettings, RouletteSessionService, createServices, } from './session-service.js';

package/lib/models.d.ts

@@ -0,0 +1,41 @@
+import type { Models } from '@zhin.js/core';
+export type RouletteSessionStatus = 'active' | 'finished' | 'aborted';
+declare module '@zhin.js/core' {
+    interface Models {
+        roulette_sessions: {
+            id: string;
+            adapter: string;
+            endpoint: string;
+            channel_type: string;
+            channel_id: string;
+            channel_key: string;
+            /** Exact Endpoint identity (`conversation.endpoint`), used for the mute lookup. */
+            endpoint_adapter: string;
+            endpoint_id: string;
+            host_id: string;
+            state_json: string;
+            phase: string;
+            turn: string;
+            revision: number;
+            processed_actions: string;
+            /** Epoch ms when the lobby or the current turn times out; 0 once the game is over. */
+            deadline_at: number;
+            status: RouletteSessionStatus;
+            updated_at: number;
+            created_at: number;
+        };
+        roulette_group_settings: {
+            /** The channel key, one row per group. */
+            id: string;
+            mute_penalty: number;
+            updated_by: string;
+            updated_at: number;
+        };
+    }
+}
+export type RouletteSessionRow = Models['roulette_sessions'];
+export type RouletteGroupSettingsRow = Models['roulette_group_settings'];
+export declare const ROULETTE_TABLES: readonly ["roulette_sessions", "roulette_group_settings"];
+export declare function defineHostTables(database: {
+    define(name: string, definition: Record<string, unknown>): void;
+}): void;

package/lib/models.js

@@ -0,0 +1,29 @@
+export const ROULETTE_TABLES = ['roulette_sessions', 'roulette_group_settings'];
+export function defineHostTables(database) {
+    database.define('roulette_sessions', {
+        id: { type: 'text', primary: true },
+        adapter: { type: 'text', nullable: false },
+        endpoint: { type: 'text', nullable: false },
+        channel_type: { type: 'text', nullable: false },
+        channel_id: { type: 'text', nullable: false },
+        channel_key: { type: 'text', nullable: false },
+        endpoint_adapter: { type: 'text', default: '' },
+        endpoint_id: { type: 'text', default: '' },
+        host_id: { type: 'text', nullable: false },
+        state_json: { type: 'text', nullable: false },
+        phase: { type: 'text', default: 'lobby' },
+        turn: { type: 'text', default: '' },
+        revision: { type: 'integer', default: 0 },
+        processed_actions: { type: 'text', default: '[]' },
+        deadline_at: { type: 'bigint', default: 0 },
+        status: { type: 'text', default: 'active' },
+        updated_at: { type: 'bigint', default: 0 },
+        created_at: { type: 'bigint', default: 0 },
+    });
+    database.define('roulette_group_settings', {
+        id: { type: 'text', primary: true },
+        mute_penalty: { type: 'integer', default: 0 },
+        updated_by: { type: 'text', default: '' },
+        updated_at: { type: 'bigint', default: 0 },
+    });
+}

package/lib/mute-penalty.d.ts

@@ -0,0 +1,31 @@
+import { adapterFeatureId } from 'zhin.js/adapter';
+/**
+ * Where a game was played: the exact Endpoint identity from `message.conversation.endpoint`
+ * (adapter plugin owner + Endpoint capability id) plus the conversation itself.
+ */
+export interface PenaltyConversation {
+    readonly endpointAdapter: string;
+    readonly endpointId: string;
+    readonly kind: string;
+    readonly id: string;
+}
+export type MuteSupport = 
+/** The live Endpoint's management port implements `muteGroupMember` and this is a group. */
+'supported'
+/** Muting only exists for group members (not private chats or channels). */
+ | 'not-a-group'
+/** No adapter projection, no such Endpoint, or its management port cannot mute. */
+ | 'unsupported';
+/**
+ * The only mute surface the game uses. It never looks at adapter names: support
+ * is whatever the live Endpoint's platform-neutral `EndpointManagement` implements.
+ */
+export interface MutePenaltyPort {
+    support(conversation: PenaltyConversation): MuteSupport;
+    mute(conversation: PenaltyConversation, userId: string, durationSeconds: number): Promise<void>;
+}
+/** The capability context of a command, middleware or schedule run. */
+export interface AdapterProjectionContext {
+    project<T>(feature: typeof adapterFeatureId): T;
+}
+export declare function resolveMutePenalty(context: AdapterProjectionContext): MutePenaltyPort;

package/lib/mute-penalty.js

@@ -0,0 +1,53 @@
+import { adapterFeatureId, resolveEndpointManagement } from 'zhin.js/adapter';
+export function resolveMutePenalty(context) {
+    return {
+        support(conversation) {
+            if (conversation.kind !== 'group')
+                return 'not-a-group';
+            return findMuteGroupMember(context, conversation) ? 'supported' : 'unsupported';
+        },
+        async mute(conversation, userId, durationSeconds) {
+            const muteGroupMember = findMuteGroupMember(context, conversation);
+            if (!muteGroupMember) {
+                throw new Error('This Endpoint cannot mute group members');
+            }
+            await muteGroupMember(conversation.id, userId, durationSeconds);
+        },
+    };
+}
+/** project(adapterFeatureId) → connection(adapter, endpointId) → resolveEndpointManagement → muteGroupMember. */
+function findMuteGroupMember(context, conversation) {
+    const adapters = readAdapterProjection(context);
+    if (!adapters)
+        return undefined;
+    if (!conversation.endpointAdapter || !conversation.endpointId)
+        return undefined;
+    let endpoint;
+    try {
+        endpoint = adapters.connection(conversation.endpointAdapter, conversation.endpointId);
+    }
+    catch {
+        return undefined;
+    }
+    const management = resolveEndpointManagement(endpoint);
+    const muteGroupMember = management?.muteGroupMember;
+    if (typeof muteGroupMember !== 'function')
+        return undefined;
+    return muteGroupMember.bind(management);
+}
+function readAdapterProjection(context) {
+    let projection;
+    try {
+        projection = context.project(adapterFeatureId);
+    }
+    catch {
+        // No Adapter Feature in this runtime: score only.
+        return undefined;
+    }
+    if (!projection || typeof projection !== 'object')
+        return undefined;
+    const lookup = projection;
+    if (typeof lookup.connection !== 'function')
+        return undefined;
+    return lookup;
+}

package/lib/roulette-actions.d.ts

@@ -0,0 +1,4 @@
+export type RouletteCommandAction = 'help' | 'open' | 'join' | 'start' | 'fire' | 'leave' | 'cancel' | 'status' | 'penalty-on' | 'penalty-off' | 'penalty-status';
+/** Empty input means help; unknown words return null so normal chat is never hijacked. */
+export declare function normalizeRouletteAction(raw: string): RouletteCommandAction | null;
+export declare const ROULETTE_HELP: string;

package/lib/roulette-actions.js

@@ -0,0 +1,51 @@
+const ACTION_WORDS = {
+    help: 'help',
+    帮助: 'help',
+    规则: 'help',
+    open: 'open',
+    开局: 'open',
+    创建: 'open',
+    join: 'join',
+    加入: 'join',
+    start: 'start',
+    开始: 'start',
+    fire: 'fire',
+    shoot: 'fire',
+    开枪: 'fire',
+    扣动扳机: 'fire',
+    leave: 'leave',
+    退出: 'leave',
+    离开: 'leave',
+    认输: 'leave',
+    cancel: 'cancel',
+    取消: 'cancel',
+    status: 'status',
+    状态: 'status',
+    'mute-on': 'penalty-on',
+    开启禁言: 'penalty-on',
+    'mute-off': 'penalty-off',
+    关闭禁言: 'penalty-off',
+    mute: 'penalty-status',
+    禁言: 'penalty-status',
+};
+/** Empty input means help; unknown words return null so normal chat is never hijacked. */
+export function normalizeRouletteAction(raw) {
+    const word = raw.trim();
+    if (!word)
+        return 'help';
+    return ACTION_WORDS[word] ?? ACTION_WORDS[word.toLowerCase()] ?? null;
+}
+export const ROULETTE_HELP = [
+    '🔫 俄罗斯轮盘（2 人起，轮流开枪，中弹者输）',
+    '轮盘 开局 — 创建一局并上桌',
+    '轮盘 加入 — 加入等待中的对局',
+    '轮盘 开始 — 房主开局（弹巢随机装 1 发子弹）',
+    '开枪 / 轮盘 开枪 — 轮到你时扣动扳机',
+    '轮盘 退出 — 等待时离开；对局中离开算认输',
+    '轮盘 取消 — 房主、群主、群管理员或机器人管理员取消本局（不计分）',
+    '轮盘 状态 — 查看当前对局',
+    '轮盘 禁言 / 开启禁言 / 关闭禁言 — 查看或切换本群的禁言惩罚（默认关闭）',
+    '',
+    '规则：按加入顺序轮流开枪；轮到的人超时不开枪判负；幸存者各记 1 胜，输家记 1 负。',
+    '战绩与排行：「战绩」「排行 轮盘」。',
+].join('\n');

package/lib/roulette-command.d.ts

@@ -0,0 +1,6 @@
+import { type RouletteCapabilityContext } from './runtime.js';
+/**
+ * Shared entry for the `roulette` command and the `轮盘` alias middleware.
+ * Returns null for unknown words so the alias middleware lets the chat through.
+ */
+export declare function runRouletteCommand(context: RouletteCapabilityContext, input: unknown, rawAction: string): Promise<string | null>;

package/lib/roulette-command.js

@@ -0,0 +1,22 @@
+import { messageFromCommandInput } from '@zhin.js/game-kit';
+import { runRouletteAction } from './game-flow.js';
+import { normalizeRouletteAction, ROULETTE_HELP } from './roulette-actions.js';
+import { endpointOf, resolveRouletteFlow, senderRolesOf } from './runtime.js';
+/**
+ * Shared entry for the `roulette` command and the `轮盘` alias middleware.
+ * Returns null for unknown words so the alias middleware lets the chat through.
+ */
+export async function runRouletteCommand(context, input, rawAction) {
+    const action = normalizeRouletteAction(rawAction);
+    if (!action)
+        return null;
+    if (action === 'help')
+        return ROULETTE_HELP;
+    const flow = resolveRouletteFlow(context);
+    const actor = {
+        message: messageFromCommandInput(input),
+        endpoint: endpointOf(input),
+        roles: senderRolesOf(input),
+    };
+    return runRouletteAction(flow, actor, action);
+}

package/lib/runtime.d.ts

@@ -0,0 +1,16 @@
+import { type Token } from 'zhin.js';
+import type { RouletteFlow } from './game-flow.js';
+import { type AdapterProjectionContext } from './mute-penalty.js';
+import type { EndpointIdentity, RouletteServices } from './session-service.js';
+/** Owner-scoped services consumed by discovered commands, middleware and the deadline job. */
+export declare const rouletteServicesToken: Token<RouletteServices>;
+/** A command, middleware or schedule capability context. */
+export interface RouletteCapabilityContext extends AdapterProjectionContext {
+    use<T>(token: Token<T>): T;
+    readonly config?: unknown;
+}
+export declare function resolveRouletteFlow(context: RouletteCapabilityContext): RouletteFlow;
+/** Framework roles (master / trusted / user) of whoever sent the message. */
+export declare function senderRolesOf(input: unknown): readonly string[];
+/** `message.conversation.endpoint`, or an empty identity (no mute possible) when absent. */
+export declare function endpointOf(input: unknown): EndpointIdentity;

package/lib/runtime.js

@@ -0,0 +1,40 @@
+import { createToken } from 'zhin.js';
+import { resolveRouletteConfig } from './config.js';
+import { resolveMutePenalty } from './mute-penalty.js';
+/** Owner-scoped services consumed by discovered commands, middleware and the deadline job. */
+export const rouletteServicesToken = createToken('zhin.game.roulette.services');
+export function resolveRouletteFlow(context) {
+    return {
+        services: context.use(rouletteServicesToken),
+        config: resolveRouletteConfig(context.config),
+        penalty: resolveMutePenalty(context),
+    };
+}
+/** Framework roles (master / trusted / user) of whoever sent the message. */
+export function senderRolesOf(input) {
+    if (!input || typeof input !== 'object')
+        return [];
+    const sender = input.sender;
+    if (!sender || typeof sender !== 'object')
+        return [];
+    const roles = sender.roles;
+    if (!Array.isArray(roles))
+        return [];
+    return roles.filter((role) => typeof role === 'string');
+}
+/** `message.conversation.endpoint`, or an empty identity (no mute possible) when absent. */
+export function endpointOf(input) {
+    const empty = { adapter: '', id: '' };
+    if (!input || typeof input !== 'object')
+        return empty;
+    const conversation = input.conversation;
+    if (!conversation || typeof conversation !== 'object')
+        return empty;
+    const endpoint = conversation.endpoint;
+    if (!endpoint || typeof endpoint !== 'object')
+        return empty;
+    const identity = endpoint;
+    if (typeof identity.adapter !== 'string' || typeof identity.id !== 'string')
+        return empty;
+    return { adapter: identity.adapter, id: identity.id };
+}

package/lib/session-service.d.ts

@@ -0,0 +1,59 @@
+import type { Database, Models } from '@zhin.js/core';
+import { VersionedSessionService, type GameMessageLike } from '@zhin.js/game-kit';
+import type { RouletteConfig } from './config.js';
+import { type RoulettePlayer, type RouletteState } from './engine.js';
+import type { RouletteSessionRow } from './models.js';
+export type RouletteDatabase = Database<unknown, Models, string>;
+/** `message.conversation.endpoint`: the adapter plugin owner and the Endpoint capability id. */
+export interface EndpointIdentity {
+    readonly adapter: string;
+    readonly id: string;
+}
+export type RouletteAction = {
+    readonly type: 'join';
+    readonly player: RoulettePlayer;
+} | {
+    readonly type: 'start';
+} | {
+    readonly type: 'fire';
+} | {
+    readonly type: 'leave';
+} | {
+    readonly type: 'cancel';
+} | {
+    readonly type: 'expire';
+};
+export interface RouletteActionResult {
+    readonly session: RouletteSessionRow;
+    readonly state: RouletteState;
+    /** False when an identical action id was already applied (adapter retry). */
+    readonly applied: boolean;
+}
+export interface RouletteServiceOptions {
+    /** Picks the loaded chamber when a round starts; secure random by default. */
+    readonly chooseBulletChamber?: (chamberCount: number) => number;
+}
+export declare class RouletteSessionService extends VersionedSessionService<RouletteSessionRow> {
+    #private;
+    constructor(database: RouletteDatabase, options?: RouletteServiceOptions);
+    createLobby(message: GameMessageLike, endpoint: EndpointIdentity, config: RouletteConfig): Promise<RouletteSessionRow>;
+    /** Every seated player counts as busy, not just the host. */
+    getActiveForUser(channelKeyValue: string, userId: string): Promise<RouletteSessionRow | null>;
+    applyAction(session: RouletteSessionRow, actorId: string, action: RouletteAction, config: RouletteConfig): Promise<RouletteActionResult>;
+    /** Open sessions whose lobby or turn deadline has passed. */
+    listOverdue(now: number): Promise<readonly RouletteSessionRow[]>;
+}
+/** Per-group switches. The mute penalty is off until a group turns it on. */
+export declare class RouletteGroupSettings {
+    #private;
+    constructor(database: RouletteDatabase);
+    isMutePenaltyEnabled(channelKeyValue: string): Promise<boolean>;
+    setMutePenalty(channelKeyValue: string, enabled: boolean, actorId: string): Promise<void>;
+}
+export interface RouletteServices {
+    readonly sessions: RouletteSessionService;
+    readonly settings: RouletteGroupSettings;
+}
+export declare function createServices(database: RouletteDatabase, options?: RouletteServiceOptions): RouletteServices;
+export declare function stateOf(session: RouletteSessionRow): RouletteState;
+export declare function playerFromMessage(message: GameMessageLike): RoulettePlayer;