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

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;

package/lib/session-service.js

@@ -0,0 +1,167 @@
+import { VersionedSessionService, channelKey, generateCompactId, secureRandomInt, } from '@zhin.js/game-kit';
+import { cancelGame, createLobby, currentPlayer, decodeRouletteState, expireLobby, expireTurn, isOpen, joinLobby, leaveGame, pullTrigger, startRound, } from './engine.js';
+export class RouletteSessionService extends VersionedSessionService {
+    #chooseBulletChamber;
+    constructor(database, options = {}) {
+        super(database, {
+            gameId: 'roulette',
+            table: 'roulette_sessions',
+            userFields: ['host_id'],
+            projectOutcomes: projectRouletteOutcomes,
+        });
+        this.#chooseBulletChamber = options.chooseBulletChamber ?? secureRandomInt;
+    }
+    async createLobby(message, endpoint, config) {
+        const now = Date.now();
+        const host = playerFromMessage(message);
+        const state = createLobby(host, tableRules(config));
+        return this.createRow({
+            id: generateCompactId('rlt_'),
+            adapter: String(message.$adapter),
+            endpoint: message.$endpoint,
+            channel_type: message.$channel.type,
+            channel_id: message.$channel.id,
+            channel_key: channelKey(message),
+            endpoint_adapter: endpoint.adapter,
+            endpoint_id: endpoint.id,
+            host_id: host.id,
+            state_json: JSON.stringify(state),
+            phase: state.phase,
+            turn: '',
+            revision: 0,
+            processed_actions: '[]',
+            deadline_at: now + config.lobbyTimeoutSeconds * 1000,
+            status: 'active',
+            updated_at: now,
+            created_at: now,
+        });
+    }
+    /** Every seated player counts as busy, not just the host. */
+    async getActiveForUser(channelKeyValue, userId) {
+        const rows = await this.model.findAll({ channel_key: channelKeyValue, status: 'active' });
+        const seated = rows.find((row) => decodeRouletteState(row.state_json).players.some((player) => player.id === userId));
+        return seated ?? null;
+    }
+    async applyAction(session, actorId, action, config) {
+        if (action.type === 'join') {
+            await this.assertPlayersAvailable(session.channel_key, [action.player.id]);
+        }
+        const result = await this.mutateSession(session.id, {
+            actionId: `${session.id}:${session.revision}:${actorId}:${action.type}`,
+            expectedRevision: session.revision,
+            apply: (current) => {
+                const before = decodeRouletteState(current.state_json);
+                const after = this.#transition(before, actorId, action, config);
+                return rowPatch(after, config, Date.now());
+            },
+        });
+        return {
+            session: result.session,
+            state: decodeRouletteState(result.session.state_json),
+            applied: result.kind === 'applied',
+        };
+    }
+    /** Open sessions whose lobby or turn deadline has passed. */
+    async listOverdue(now) {
+        const rows = await this.model.findAll({ status: 'active' });
+        return rows.filter((row) => row.deadline_at > 0 && row.deadline_at <= now);
+    }
+    #transition(state, actorId, action, config) {
+        switch (action.type) {
+            case 'join':
+                return joinLobby(state, action.player, tableRules(config));
+            case 'start':
+                return startRound(state, actorId, this.#chooseBulletChamber(state.chamberCount));
+            case 'fire':
+                return pullTrigger(state, actorId).state;
+            case 'leave':
+                return leaveGame(state, actorId);
+            case 'cancel':
+                return cancelGame(state);
+            case 'expire':
+                return state.phase === 'lobby' ? expireLobby(state) : expireTurn(state);
+        }
+    }
+}
+/** Per-group switches. The mute penalty is off until a group turns it on. */
+export class RouletteGroupSettings {
+    #model;
+    constructor(database) {
+        const model = database.models.get('roulette_group_settings');
+        if (!model)
+            throw new Error('roulette_group_settings not registered');
+        this.#model = model;
+    }
+    async isMutePenaltyEnabled(channelKeyValue) {
+        const row = await this.#model.findOne({ id: channelKeyValue });
+        return row?.mute_penalty === 1;
+    }
+    async setMutePenalty(channelKeyValue, enabled, actorId) {
+        const patch = {
+            mute_penalty: enabled ? 1 : 0,
+            updated_by: actorId,
+            updated_at: Date.now(),
+        };
+        const existing = await this.#model.findOne({ id: channelKeyValue });
+        if (existing) {
+            await this.#model.updateWhere({ id: channelKeyValue }, patch);
+            return;
+        }
+        await this.#model.create({ id: channelKeyValue, ...patch });
+    }
+}
+export function createServices(database, options = {}) {
+    return {
+        sessions: new RouletteSessionService(database, options),
+        settings: new RouletteGroupSettings(database),
+    };
+}
+export function stateOf(session) {
+    return decodeRouletteState(session.state_json);
+}
+export function playerFromMessage(message) {
+    const name = message.$sender.name?.trim() || message.$sender.id;
+    return { id: message.$sender.id, name };
+}
+function tableRules(config) {
+    return { chamberCount: config.chambers, maxPlayers: config.maxPlayers };
+}
+function rowPatch(state, config, now) {
+    return {
+        state_json: JSON.stringify(state),
+        phase: state.phase,
+        turn: currentPlayer(state)?.id ?? '',
+        host_id: state.hostId,
+        deadline_at: deadlineFor(state, config, now),
+        status: statusFor(state),
+    };
+}
+function deadlineFor(state, config, now) {
+    if (state.phase === 'playing')
+        return now + config.turnTimeoutSeconds * 1000;
+    if (state.phase === 'lobby')
+        return now + config.lobbyTimeoutSeconds * 1000;
+    return 0;
+}
+function statusFor(state) {
+    if (isOpen(state))
+        return 'active';
+    if (state.phase === 'finished')
+        return 'finished';
+    return 'aborted';
+}
+/** Survivors win one point each; the loser records a loss. Aborted games record nothing. */
+function projectRouletteOutcomes(session) {
+    if (session.status !== 'finished')
+        return [];
+    const state = decodeRouletteState(session.state_json);
+    return state.players.map((player) => {
+        const lost = player.id === state.loserId;
+        return {
+            userId: player.id,
+            userName: player.name,
+            result: lost ? 'lost' : 'won',
+            score: lost ? 0 : 1,
+        };
+    });
+}

package/lib/view.d.ts

@@ -0,0 +1,10 @@
+import type { RouletteConfig } from './config.js';
+import { type RoulettePlayer, type RouletteState } from './engine.js';
+export declare const ROULETTE_TITLE = "\uD83D\uDD2B \u4FC4\u7F57\u65AF\u8F6E\u76D8";
+export declare function describeLobby(state: RouletteState, config: RouletteConfig): string;
+export declare function describeRoundStart(state: RouletteState, config: RouletteConfig): string;
+export declare function describeTurn(state: RouletteState, config: RouletteConfig): string;
+export declare function describeClick(shooter: RoulettePlayer, state: RouletteState, config: RouletteConfig): string;
+export declare function describeEnding(state: RouletteState): string;
+export declare function describeAbort(state: RouletteState): string;
+export declare function describeStatus(state: RouletteState, config: RouletteConfig): string;

package/lib/view.js

@@ -0,0 +1,73 @@
+import { MIN_ROULETTE_PLAYERS, currentPlayer, loserOf, remainingChambers, survivorsOf, } from './engine.js';
+export const ROULETTE_TITLE = '🔫 俄罗斯轮盘';
+export function describeLobby(state, config) {
+    const host = state.players.find((player) => player.id === state.hostId);
+    const lines = [
+        `${ROULETTE_TITLE} · 等待玩家（${state.players.length}/${config.maxPlayers}）`,
+        `玩家：${listNames(state.players)}`,
+        `发送「轮盘 加入」上桌；${host?.name ?? '房主'} 发送「轮盘 开始」开局（至少 ${MIN_ROULETTE_PLAYERS} 人）。`,
+        `${config.lobbyTimeoutSeconds} 秒内没有开始会自动解散。`,
+    ];
+    return lines.join('\n');
+}
+export function describeRoundStart(state, config) {
+    const order = state.players.map((player, index) => `${index + 1}. ${player.name}`);
+    const lines = [
+        `${ROULETTE_TITLE} · 开局！${state.chamberCount} 个弹巢里装了 1 发子弹，已转好弹巢。`,
+        '开枪顺序：',
+        ...order,
+        describeTurn(state, config),
+    ];
+    return lines.join('\n');
+}
+export function describeTurn(state, config) {
+    const shooter = currentPlayer(state);
+    if (!shooter)
+        return '';
+    return `👉 轮到 ${shooter.name}：发送「开枪」，${config.turnTimeoutSeconds} 秒内不开枪判负。`
+        + `（剩余 ${remainingChambers(state)} 个弹巢）`;
+}
+export function describeClick(shooter, state, config) {
+    return [`咔哒……${shooter.name} 的这一枪是空膛。`, describeTurn(state, config)].join('\n');
+}
+export function describeEnding(state) {
+    const loser = loserOf(state);
+    if (!loser)
+        return describeAbort(state);
+    const headline = endingHeadline(state, loser);
+    const survivors = survivorsOf(state);
+    return [
+        headline,
+        `🏆 幸存：${listNames(survivors)}（各 +1 胜）`,
+        '发送「排行 轮盘」查看本群排行。',
+    ].join('\n');
+}
+export function describeAbort(state) {
+    if (state.endReason === 'lobby-expired')
+        return `${ROULETTE_TITLE} 长时间没有开始，已自动解散。`;
+    if (state.endReason === 'lobby-empty')
+        return `${ROULETTE_TITLE} 所有人都离开了，已解散。`;
+    return `${ROULETTE_TITLE} 已取消，本局不计分。`;
+}
+export function describeStatus(state, config) {
+    if (state.phase === 'lobby')
+        return describeLobby(state, config);
+    const lines = [
+        `${ROULETTE_TITLE} · 进行中，已开 ${state.pullsMade} 枪`,
+        `玩家：${listNames(state.players)}`,
+        describeTurn(state, config),
+    ];
+    return lines.join('\n');
+}
+function endingHeadline(state, loser) {
+    if (state.endReason === 'turn-timeout')
+        return `⌛ ${loser.name} 超时没有开枪，判负！`;
+    if (state.endReason === 'forfeit')
+        return `🏳️ ${loser.name} 中途离场，判负！`;
+    return `💥 砰！${loser.name} 中弹出局（第 ${state.pullsMade} 枪）。`;
+}
+function listNames(players) {
+    if (players.length === 0)
+        return '无';
+    return players.map((player) => player.name).join('、');
+}

package/middlewares/roulette-alias/index.js

@@ -0,0 +1,10 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { defineGameCommandAliasMiddleware } from '@zhin.js/game-kit';
+import { runRouletteCommand } from "../../lib/roulette-command.js";
+/** `轮盘 加入` / `/轮盘赌 开枪` / `roulette start` route to the same logic as the command. */
+export default defineGameCommandAliasMiddleware({
+    aliases: ['轮盘', '轮盘赌', 'roulette'],
+    async run(action, input, context) {
+        return runRouletteCommand(context, input, action);
+    },
+});

package/middlewares/roulette-fire/index.js

@@ -0,0 +1,30 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { channelKey, messageFromCommandInput } from '@zhin.js/game-kit';
+import { defineMiddleware } from 'zhin.js/middleware';
+import { runRouletteCommand } from "../../lib/roulette-command.js";
+import { rouletteServicesToken } from "../../lib/runtime.js";
+const FIRE_WORDS = ['开枪', '扣动扳机'];
+/**
+ * A bare 「开枪」 fires only for the player whose turn it is in this group,
+ * so the word stays ordinary chat everywhere else.
+ */
+export default defineMiddleware({
+    target: 'inbound',
+    async handle(context, next) {
+        const text = context.input.content?.trim() ?? '';
+        if (!FIRE_WORDS.includes(text)) {
+            await next();
+            return;
+        }
+        const message = messageFromCommandInput(context.input);
+        const services = context.use(rouletteServicesToken);
+        const session = await services.sessions.getActiveByChannel(channelKey(message));
+        if (!session || session.turn !== message.$sender.id) {
+            await next();
+            return;
+        }
+        const reply = await runRouletteCommand(context, context.input, 'fire');
+        if (reply)
+            await context.input.$reply(reply);
+    },
+});