@zhin.js/plugin-roulette 0.1.14 → 0.1.15

package/src/deadline-job.ts

@@ -0,0 +1,49 @@
+import { outboundHostToken, type OutboundHost } from 'zhin.js';
+import { gameTargetFromKey, sendGameSessionMessage } from '@zhin.js/game-kit';
+import { expireOverdueSessions, type ExpiredSessionNotice } from './game-flow.js';
+import { resolveRouletteFlow, rouletteFeatureGateStore, type RouletteCapabilityContext, type RouletteFeatureGate } from './runtime.js';
+
+/** Turn and lobby deadlines are checked every five seconds. */
+export const DEADLINE_CRON = '*/5 * * * * *';
+
+/**
+ * One deadline sweep. It runs with the schedule's capability context, so a
+ * timed-out loser gets the same mute check (adapter projection) as one who
+ * was shot in a command.
+ */
+export async function runDeadlineSweep(context: RouletteCapabilityContext, now: number): Promise<void> {
+  const flow = resolveRouletteFlow(context);
+  const outbound = readOutbound(context);
+  const enabledFor = readFeatureGate(context);
+  await expireOverdueSessions(flow, now, (notice) => {
+    if (outbound) return announce(outbound, notice);
+  }, enabledFor && ((session) => {
+    const target = gameTargetFromKey(session.channel_key);
+    return !target || enabledFor.isEnabledFor(target);
+  }));
+}
+
+function readFeatureGate(context: RouletteCapabilityContext): RouletteFeatureGate | undefined {
+  try {
+    return context.use(rouletteFeatureGateStore);
+  } catch {
+    return undefined;
+  }
+}
+
+function readOutbound(context: RouletteCapabilityContext): OutboundHost | undefined {
+  try {
+    return context.use(outboundHostToken);
+  } catch {
+    return undefined;
+  }
+}
+
+async function announce(outbound: OutboundHost, notice: ExpiredSessionNotice): Promise<void> {
+  const session = notice.session;
+  try {
+    await sendGameSessionMessage({ outbound, session, content: notice.text });
+  } catch {
+    // The result is already stored; a failed notice must not stop the other sessions.
+  }
+}

package/src/engine.ts

@@ -0,0 +1,245 @@
+import { createMessages, type Locale } from 'zhin.js/i18n';
+/**
+ * Pure Russian roulette rules. No I/O, no clock and no randomness: callers pass
+ * the bullet position in, so every transition is deterministic and testable.
+ */
+
+export const ROULETTE_STATE_VERSION = 1;
+
+export type RoulettePhase = 'lobby' | 'playing' | 'finished' | 'aborted';
+
+export type RouletteEndReason =
+  | 'shot'
+  | 'turn-timeout'
+  | 'forfeit'
+  | 'cancelled'
+  | 'lobby-expired'
+  | 'lobby-empty';
+
+export interface RoulettePlayer {
+  readonly id: string;
+  readonly name: string;
+}
+
+export interface RouletteState {
+  readonly schemaVersion: typeof ROULETTE_STATE_VERSION;
+  readonly phase: RoulettePhase;
+  readonly hostId: string;
+  readonly players: readonly RoulettePlayer[];
+  readonly chamberCount: number;
+  /** Zero-based chamber holding the bullet; -1 until the round starts. */
+  readonly bulletChamber: number;
+  /** Trigger pulls so far; the next pull fires chamber `pullsMade`. */
+  readonly pullsMade: number;
+  /** Index into `players` of whoever must pull next. */
+  readonly turnIndex: number;
+  readonly loserId?: string;
+  readonly endReason?: RouletteEndReason;
+}
+
+export interface RouletteTableRules {
+  readonly chamberCount: number;
+  readonly maxPlayers: number;
+}
+
+export const MIN_ROULETTE_PLAYERS = 2;
+
+export type TriggerOutcome = 'click' | 'bang';
+
+export interface TriggerResult {
+  readonly state: RouletteState;
+  readonly outcome: TriggerOutcome;
+  readonly shooter: RoulettePlayer;
+}
+
+/** A rule violation the player should read, e.g. firing out of turn. */
+export class RouletteRuleError extends Error {
+  constructor(readonly code: RouletteRuleCode, readonly parameters: Readonly<Record<string, string | number>> = {}) {
+    super(ruleMessages('zh-CN', code, parameters));
+    this.name = 'RouletteRuleError';
+  }
+
+  format(locale?: Locale): string { return ruleMessages(locale, this.code, this.parameters); }
+}
+
+export function createLobby(host: RoulettePlayer, rules: RouletteTableRules): RouletteState {
+  return {
+    schemaVersion: ROULETTE_STATE_VERSION,
+    phase: 'lobby',
+    hostId: host.id,
+    players: [host],
+    chamberCount: rules.chamberCount,
+    bulletChamber: -1,
+    pullsMade: 0,
+    turnIndex: 0,
+  };
+}
+
+export function joinLobby(
+  state: RouletteState,
+  player: RoulettePlayer,
+  rules: RouletteTableRules,
+): RouletteState {
+  requirePhase(state, 'lobby', 'cannotJoin');
+  if (findPlayer(state, player.id)) {
+    throw new RouletteRuleError('alreadyJoined');
+  }
+  if (state.players.length >= rules.maxPlayers) {
+    throw new RouletteRuleError('full', { max: rules.maxPlayers });
+  }
+  return { ...state, players: [...state.players, player] };
+}
+
+export function startRound(
+  state: RouletteState,
+  actorId: string,
+  bulletChamber: number,
+): RouletteState {
+  requirePhase(state, 'lobby', 'started');
+  if (actorId !== state.hostId) {
+    throw new RouletteRuleError('hostOnly');
+  }
+  if (state.players.length < MIN_ROULETTE_PLAYERS) {
+    throw new RouletteRuleError('minimum', { min: MIN_ROULETTE_PLAYERS });
+  }
+  if (!Number.isInteger(bulletChamber) || bulletChamber < 0 || bulletChamber >= state.chamberCount) {
+    throw new RangeError(`bulletChamber must be within 0..${state.chamberCount - 1}`);
+  }
+  return {
+    ...state,
+    phase: 'playing',
+    bulletChamber,
+    pullsMade: 0,
+    turnIndex: 0,
+  };
+}
+
+export function pullTrigger(state: RouletteState, actorId: string): TriggerResult {
+  requirePhase(state, 'playing', 'notStarted');
+  const shooter = currentPlayer(state);
+  if (!shooter) throw new RouletteRuleError('noPlayer');
+  if (shooter.id !== actorId) {
+    throw new RouletteRuleError('notTurn', { name: shooter.name });
+  }
+  const firedChamber = state.pullsMade;
+  const pullsMade = state.pullsMade + 1;
+  if (firedChamber === state.bulletChamber) {
+    const finished = finishWithLoser({ ...state, pullsMade }, shooter.id, 'shot');
+    return { state: finished, outcome: 'bang', shooter };
+  }
+  const turnIndex = (state.turnIndex + 1) % state.players.length;
+  return { state: { ...state, pullsMade, turnIndex }, outcome: 'click', shooter };
+}
+
+/**
+ * Leaving the lobby just removes the player. Leaving a running round is a
+ * forfeit: the leaver loses, so nobody can dodge the bullet by walking away.
+ */
+export function leaveGame(state: RouletteState, playerId: string): RouletteState {
+  const leaver = findPlayer(state, playerId);
+  if (!leaver) throw new RouletteRuleError('notJoined');
+  if (state.phase === 'playing') {
+    return finishWithLoser(state, playerId, 'forfeit');
+  }
+  requirePhase(state, 'lobby', 'ended');
+  const players = state.players.filter((player) => player.id !== playerId);
+  const nextHost = players[0];
+  if (!nextHost) {
+    return { ...state, players, phase: 'aborted', endReason: 'lobby-empty' };
+  }
+  const hostId = state.hostId === playerId ? nextHost.id : state.hostId;
+  return { ...state, players, hostId };
+}
+
+/** The player on turn ran out of time: treated like a shot, they lose. */
+export function expireTurn(state: RouletteState): RouletteState {
+  requirePhase(state, 'playing', 'notStarted');
+  const late = currentPlayer(state);
+  if (!late) throw new RouletteRuleError('noPlayer');
+  return finishWithLoser(state, late.id, 'turn-timeout');
+}
+
+export function expireLobby(state: RouletteState): RouletteState {
+  requirePhase(state, 'lobby', 'started');
+  return { ...state, phase: 'aborted', endReason: 'lobby-expired' };
+}
+
+export function cancelGame(state: RouletteState): RouletteState {
+  if (!isOpen(state)) throw new RouletteRuleError('ended');
+  return { ...state, phase: 'aborted', endReason: 'cancelled' };
+}
+
+export function isOpen(state: RouletteState): boolean {
+  return state.phase === 'lobby' || state.phase === 'playing';
+}
+
+export function currentPlayer(state: RouletteState): RoulettePlayer | undefined {
+  if (state.phase !== 'playing') return undefined;
+  return state.players[state.turnIndex];
+}
+
+export function findPlayer(state: RouletteState, playerId: string): RoulettePlayer | undefined {
+  return state.players.find((player) => player.id === playerId);
+}
+
+export function loserOf(state: RouletteState): RoulettePlayer | undefined {
+  if (!state.loserId) return undefined;
+  return findPlayer(state, state.loserId);
+}
+
+export function survivorsOf(state: RouletteState): readonly RoulettePlayer[] {
+  return state.players.filter((player) => player.id !== state.loserId);
+}
+
+export function remainingChambers(state: RouletteState): number {
+  return state.chamberCount - state.pullsMade;
+}
+
+export function decodeRouletteState(json: string): RouletteState {
+  const parsed: unknown = JSON.parse(json);
+  if (!isRouletteState(parsed)) {
+    throw new TypeError('Stored roulette state is malformed');
+  }
+  return parsed;
+}
+
+function finishWithLoser(
+  state: RouletteState,
+  loserId: string,
+  endReason: RouletteEndReason,
+): RouletteState {
+  return { ...state, phase: 'finished', loserId, endReason };
+}
+
+function requirePhase(state: RouletteState, phase: RoulettePhase, code: RouletteRuleCode): void {
+  if (state.phase !== phase) throw new RouletteRuleError(code);
+}
+
+function isRouletteState(value: unknown): value is RouletteState {
+  if (!value || typeof value !== 'object') return false;
+  const state = value as Partial<RouletteState>;
+  return state.schemaVersion === ROULETTE_STATE_VERSION
+    && typeof state.phase === 'string'
+    && typeof state.hostId === 'string'
+    && Array.isArray(state.players)
+    && typeof state.chamberCount === 'number'
+    && typeof state.bulletChamber === 'number'
+    && typeof state.pullsMade === 'number'
+    && typeof state.turnIndex === 'number';
+}
+
+const ruleCatalog = {
+  cannotJoin: { 'zh-CN': "对局已经开始，不能再加入了。", en: "The game has started; you can no longer join." },
+  alreadyJoined: { 'zh-CN': "你已经在这局轮盘里了。", en: "You are already in this game." },
+  full: { 'zh-CN': "人数已满（最多 {max} 人）。", en: "The table is full (maximum {max} players)." },
+  started: { 'zh-CN': "对局已经开始了。", en: "The game has already started." },
+  hostOnly: { 'zh-CN': "只有开局的人可以开始。", en: "Only the host may start the game." },
+  minimum: { 'zh-CN': "至少需要 {min} 名玩家才能开始。", en: "At least {min} players are required." },
+  notStarted: { 'zh-CN': "对局还没开始。", en: "The game has not started." },
+  noPlayer: { 'zh-CN': "对局没有可以开枪的玩家。", en: "There is no player who can pull the trigger." },
+  notTurn: { 'zh-CN': "还没轮到你，现在轮到 {name}。", en: "It is not your turn. {name} plays next." },
+  notJoined: { 'zh-CN': "你不在这局轮盘里。", en: "You are not in this game." },
+  ended: { 'zh-CN': "对局已经结束。", en: "The game has ended." },
+} as const;
+type RouletteRuleCode = keyof typeof ruleCatalog;
+const ruleMessages = createMessages(ruleCatalog);

package/src/game-flow.ts

@@ -0,0 +1,339 @@
+import { createMessages, resolveLocale, type Locale } from 'zhin.js/i18n';
+import { gameCommandHint, GameSessionConflictError, SessionRevisionConflictError, channelKey, gameTargetFromKey, type GamePlayer } from '@zhin.js/game-kit';
+import type { RouletteConfig } from './config.js';
+import { RouletteRuleError, loserOf, type RouletteState } from './engine.js';
+import type { RouletteSessionRow } from './models.js';
+import type { MutePenaltyPort, PenaltyConversation } from './mute-penalty.js';
+import { getRouletteHelp, type RouletteCommandAction } from './roulette-actions.js';
+import {
+  playerFromMessage,
+  stateOf,
+  type RouletteAction,
+  type RouletteActionResult,
+  type RouletteServices,
+} from './session-service.js';
+import {
+  describeAbort,
+  describeClick,
+  describeEnding,
+  describeLobby,
+  describeRoundStart,
+  describeStatus,
+} from './view.js';
+
+/** Everything one action needs, resolved from the current runtime generation. */
+export interface RouletteFlow {
+  readonly services: RouletteServices;
+  readonly config: RouletteConfig;
+  readonly penalty: MutePenaltyPort;
+}
+
+/** Who sent the action, from the runtime message. */
+export interface RouletteActor {
+  readonly message: GamePlayer;
+  readonly roles: readonly string[];
+}
+
+export interface ExpiredSessionNotice {
+  readonly session: RouletteSessionRow;
+  readonly text: string;
+}
+
+const DEADLINE_ACTOR = 'deadline';
+/** zhin chat role `trusted` or higher (ADR 0056; platform standing does not count). */
+const MANAGER_ROLES: readonly string[] = ['trusted'];
+function noGame(message: GamePlayer): string { return messages(message.locale, 'noGame') + gameCommandHint(message, 'roulette', 'open'); }
+
+export async function runRouletteAction(
+  flow: RouletteFlow,
+  actor: RouletteActor,
+  action: RouletteCommandAction,
+): Promise<string> {
+  return flow.services.sessions.runInScope({ scope: channelKey(actor.message), run: async () => {
+    const message = actor.message;
+    const locale = resolveLocale(message.locale);
+    if (action === 'help') return getRouletteHelp(message);
+    if (message.target.kind === 'private') return messages(locale, 'text1');
+    if (action === 'penalty-on' || action === 'penalty-off' || action === 'penalty-status') {
+      return handlePenaltySetting(flow, actor, action);
+    }
+
+    const notices: string[] = [];
+    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: RouletteFlow,
+  now: number,
+  onNotice?: (notice: ExpiredSessionNotice) => Promise<void> | void,
+  isEnabled?: (session: RouletteSessionRow) => boolean,
+): Promise<readonly ExpiredSessionNotice[]> {
+  const overdue = await flow.services.sessions.listOverdue(now);
+  const notices: ExpiredSessionNotice[] = [];
+  for (const session of overdue) {
+    try {
+      await flow.services.sessions.runInScope({ scope: session.channel_key, run: async () => {
+        // Switched off for this conversation (ADR 0050 / 0055): end the game silently, without a
+        // result, records, mute penalty or announcement.
+        if (isEnabled && !isEnabled(session)) {
+          await abortSilently(flow, session);
+          return;
+        }
+        const text = await expireSession(flow, session);
+        if (!text) return;
+        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: RouletteFlow,
+  actor: RouletteActor,
+  action: RouletteCommandAction,
+  session: RouletteSessionRow | null,
+): Promise<string> {
+  const message = actor.message;
+  const locale = resolveLocale(session ? session.locale : message.locale);
+  if (action === 'open') return openLobby(flow, actor, session);
+  if (!session) return noGame(message);
+  if (action === 'status') return describeStatus(stateOf(session), flow.config, { ...message, locale });
+  if (action === 'cancel' && !mayCancel(session, message, actor.roles)) {
+    return messages(locale, 'text2');
+  }
+  const gameAction = toGameAction(action, message);
+  if (!gameAction) return noGame(message);
+  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.format(locale);
+    if (error instanceof GameSessionConflictError) return error.format(locale);
+    if (error instanceof SessionRevisionConflictError) return messages(locale, 'text3');
+    throw error;
+  }
+}
+
+async function openLobby(
+  flow: RouletteFlow,
+  actor: RouletteActor,
+  session: RouletteSessionRow | null,
+): Promise<string> {
+  const locale = resolveLocale(session ? session.locale : actor.message.locale);
+  if (session) {
+    return messages(locale, 'text4', { p0: describeStatus(stateOf(session), flow.config, { ...actor.message, locale }) });
+  }
+  try {
+    const created = await flow.services.sessions.createLobby(actor.message, flow.config);
+    return describeLobby(stateOf(created), flow.config, { ...actor.message, locale });
+  } catch (error) {
+    if (error instanceof GameSessionConflictError) return error.format(locale);
+    throw error;
+  }
+}
+
+async function describeResult(
+  flow: RouletteFlow,
+  action: RouletteAction,
+  result: RouletteActionResult,
+  message: GamePlayer,
+): Promise<string> {
+  const state = result.state;
+  const locale = resolveLocale(result.session.locale);
+  const presentation = { ...message, locale };
+  if (!result.applied) return describeStatus(state, flow.config, presentation);
+  if (state.phase === 'finished') return finishText(flow, result.session, state);
+  if (state.phase === 'aborted') return describeAbort(state, presentation);
+  if (action.type === 'start') return describeRoundStart(state, flow.config, presentation);
+  if (action.type === 'fire') {
+    return describeClick(playerFromMessage(message), state, flow.config, presentation);
+  }
+  if (action.type === 'leave') {
+    return messages(locale, 'text5', { p0: playerFromMessage(message).name, p1: describeLobby(state, flow.config, presentation) });
+  }
+  return describeLobby(state, flow.config, presentation);
+}
+
+async function abortSilently(flow: RouletteFlow, session: RouletteSessionRow): Promise<void> {
+  try {
+    await flow.services.sessions.applyAction(session, DEADLINE_ACTOR, { type: 'cancel' }, flow.config);
+  } catch (error) {
+    if (error instanceof SessionRevisionConflictError) return;
+    throw error;
+  }
+}
+
+async function expireSession(flow: RouletteFlow, session: RouletteSessionRow): Promise<string> {
+  // 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, { locale: resolveLocale(result.session.locale) });
+  } 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: RouletteFlow,
+  session: RouletteSessionRow,
+  state: RouletteState,
+  penaltyEnabled?: boolean,
+): Promise<string> {
+  const penalty = await applyLoserPenalty(flow, session, state, penaltyEnabled);
+  return [describeEnding(state, { locale: resolveLocale(session.locale) }), penalty].filter(Boolean).join('\n');
+}
+
+/** Mute the loser only when this group opted in and the Endpoint declares muting. */
+async function applyLoserPenalty(
+  flow: RouletteFlow,
+  session: RouletteSessionRow,
+  state: RouletteState,
+  penaltyEnabled?: boolean,
+): Promise<string> {
+  const locale = resolveLocale(session.locale);
+  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 messages(locale, 'text6');
+  }
+  try {
+    await flow.penalty.mute(conversation, loser.id, flow.config.muteSeconds);
+    return messages(locale, 'text7', { p0: loser.name, p1: flow.config.muteSeconds });
+  } catch {
+    return messages(locale, 'text8');
+  }
+}
+
+async function handlePenaltySetting(
+  flow: RouletteFlow,
+  actor: RouletteActor,
+  action: 'penalty-on' | 'penalty-off' | 'penalty-status',
+): Promise<string> {
+  const message = actor.message;
+  const locale = resolveLocale(message.locale);
+  if (message.target.kind !== 'group') return messages(locale, 'text9');
+  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, locale);
+  }
+  if (!isManager(actor.roles)) return messages(locale, 'text10');
+  if (action === 'penalty-off') {
+    await settings.setMutePenalty(key, false, message.sender.id);
+    return messages(locale, 'text11');
+  }
+  if (support !== 'supported') {
+    return messages(locale, 'text12');
+  }
+  await settings.setMutePenalty(key, true, message.sender.id);
+  return messages(locale, 'text13', { p0: flow.config.muteSeconds });
+}
+
+function describePenaltyStatus(enabled: boolean, supported: boolean, config: RouletteConfig, locale?: Locale): string {
+  const platform = supported ? messages(locale, 'text14') : messages(locale, 'text15');
+  if (!enabled) return messages(locale, 'text16', { p0: platform });
+  return messages(locale, 'text17', { p0: config.muteSeconds, p1: platform });
+}
+
+function toGameAction(action: RouletteCommandAction, message: GamePlayer): RouletteAction | null {
+  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: RouletteSessionRow,
+  message: GamePlayer,
+  senderRoles: readonly string[],
+): boolean {
+  if (stateOf(session).hostId === message.sender.id) return true;
+  return isManager(senderRoles);
+}
+
+function isManager(senderRoles: readonly string[]): boolean {
+  return senderRoles.some((role) => MANAGER_ROLES.includes(role));
+}
+
+function isOverdue(session: RouletteSessionRow, now: number): boolean {
+  return session.deadline_at > 0 && session.deadline_at <= now;
+}
+
+export function conversationOfSession(session: RouletteSessionRow): PenaltyConversation {
+  const target = gameTargetFromKey(session.channel_key);
+  if (!target) throw new Error('Historical roulette session awaits explicit target migration');
+  return { endpointAdapter: target.endpoint.adapter, endpointId: target.endpoint.id, kind: target.kind, id: target.id };
+}
+
+function conversationOfActor(actor: RouletteActor): PenaltyConversation {
+  return {
+    endpointAdapter: actor.message.target.endpoint.adapter,
+    endpointId: actor.message.target.endpoint.id,
+    kind: actor.message.target.kind,
+    id: actor.message.target.id,
+  };
+}
+
+const messages = createMessages({
+  noGame: { 'zh-CN': '本群没有进行中的轮盘。', en: 'This group has no active roulette game.' },
+  text1: { 'zh-CN': "轮盘需要多人参与，请在群聊里玩。", en: "Roulette needs multiple players. Please play in a group chat." },
+  text2: { 'zh-CN': "只有开局的人、群主、群管理员或机器人管理员可以取消本局。", en: "Only the host, group owner, group admin or bot administrator may cancel this game." },
+  text3: { 'zh-CN': "对局状态刚刚变了，请再发一次。", en: "The game state just changed. Please try again." },
+  text4: { 'zh-CN': "本群已经有一局轮盘了。\n{p0}", en: "This group already has a roulette game.\n{p0}" },
+  text5: { 'zh-CN': "{p0} 离开了。\n{p1}", en: "{p0} left.\n{p1}" },
+  text6: { 'zh-CN': "（本群开启了禁言惩罚，但当前平台无法禁言，本局只计分。）", en: "(Mute penalties are enabled, but this platform cannot mute players. Only scores were recorded.)" },
+  text7: { 'zh-CN': "🔇 {p0} 被禁言 {p1} 秒。", en: "🔇 {p0} was muted for {p1} seconds." },
+  text8: { 'zh-CN': "（禁言没有成功，可能是机器人没有群管理权限；本局只计分。）", en: "(Muting failed, possibly because the bot lacks group management permission. Only scores were recorded.)" },
+  text9: { 'zh-CN': "禁言惩罚只能在群聊里设置。", en: "Mute penalties can only be configured in a group chat." },
+  text10: { 'zh-CN': "只有本会话 zhin 角色 trusted 及以上（owner / admin / trusted）的用户可以修改禁言惩罚。", en: "Only users with the zhin role trusted or higher (owner / admin / trusted) in this conversation may change mute penalties." },
+  text11: { 'zh-CN': "已关闭禁言惩罚，本群轮盘只计分。", en: "Mute penalties are disabled. This group now records scores only." },
+  text12: { 'zh-CN': "当前平台不支持禁言，禁言惩罚没有开启；本群轮盘只计分。", en: "This platform does not support muting. Mute penalties remain disabled; only scores are recorded." },
+  text13: { 'zh-CN': "已开启禁言惩罚：每局输家会被禁言 {p0} 秒（需要机器人有群管理权限）。", en: "Mute penalties enabled: each loser is muted for {p0} seconds (the bot needs group management permission)." },
+  text14: { 'zh-CN': "当前平台支持禁言。", en: "This platform supports muting." },
+  text15: { 'zh-CN': "当前平台不支持禁言，只能计分。", en: "This platform does not support muting; only scores are recorded." },
+  text16: { 'zh-CN': "本群禁言惩罚：关闭。{p0}", en: "Group mute penalty: off. {p0}" },
+  text17: { 'zh-CN': "本群禁言惩罚：开启，输家禁言 {p0} 秒。{p1}", en: "Group mute penalty: on, the loser is muted for {p0} seconds. {p1}" },
+});

package/src/index.ts

@@ -0,0 +1,19 @@
+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 { rouletteServicesToken, resolveRouletteFlow } from './runtime.js';
+export {
+  RouletteGroupSettings,
+  RouletteSessionService,
+  createServices,
+  type RouletteServices,
+} from './session-service.js';