@zhin.js/plugin-roulette 0.1.6 → 0.1.8

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @zhin.js/plugin-roulette
 
+## 0.1.8
+
+### Patch Changes
+
+- a9f4e48: PATCH COMPATIBILITY CUTOVER: this batch intentionally changes plugin APIs. The maintainer explicitly chose patch releases with declared version boundaries. Upgrade the complete tested dependency set; patch numbering does not promise compatibility with the removed interfaces.
+
+  The first planned floors are zhin.js 1.1.19, Core 1.1.54, Adapter 1.1.26, FeatureKit 1.1.10, Plugin Runtime 1.1.18, Runtime/Isolate 1.1.16 and Agent 1.1.45. Keep old-interface plugins with the earlier locked stack until they are migrated. Adapter's independent Feature API changes from 1.0.0 to 2.0.0; official consumers declare ^2.0.0. Existing Feature API admission rejects explicitly incompatible ranges; omitted API metadata keeps its existing behavior and does not certify compatibility. Runtime engine and patch-only release gates remain unchanged.
+
+  Use the native-Client Adapter target contract, canonical FeatureKit AdapterRegistry augmentation and named Endpoint control/management requests. Route message controls from canonical message/conversation refs; retain exact source authority and propagate caller/account/explicit-Root-stop cancellation. Replace removed Agent activity feedback exports with source-bound feedback. HMR pause/resume belongs to concrete plugin instances; plugins choose accepted-work policy without changing Controller commit/rollback authority. Cooperative worker/process control cancellation does not kill an isolate or reopen retired business admission.
+
+  Provide authenticated historical-data preview, exact selected binding, transactional application, authoritative inspection and explicit resumption, including active games. Preserve before-images and journals; never replay an unconfirmed effect, infer an account from an alias, or reuse historical permission grants. Owner V2 approvals remain inactive legacy data, while new writes use V3. Rollback requires matching software, lockfile and verified data; installing old code alone cannot read a new V3 approval file. Conflicting after-images are never overwritten.
+
+  See docs/plans/adapter-operation-version-boundaries.md and the Chinese/English upgrade guide for the complete version inventory, custom-plugin changes, acceptance and recovery sequence. These code and metadata changes do not authorize merging, publication, deployment, login, production migration or removal of installed workspace patches.
+
+- Updated dependencies [2c3610a]
+- Updated dependencies [a9f4e48]
+- Updated dependencies [f8505b0]
+  - @zhin.js/core@1.1.54
+  - @zhin.js/game-kit@1.1.19
+
+## 0.1.7
+
+### Patch Changes
+
+- Updated dependencies [c58c589]
+  - @zhin.js/core@1.1.53
+  - @zhin.js/game-kit@1.1.18
+
 ## 0.1.6
 
 ### Patch Changes

package/commands/roulette/[[action]]/index.js

@@ -1,14 +1,21 @@
 // Generated by build-plugin-runtime-entries.mjs. Do not edit.
-import { gameCommandFeedback } from '@zhin.js/game-kit';
+import { gameCommandFeedback, gamePlayerFromInput, replyGameOperation } from '@zhin.js/game-kit';
 import { defineCommand } from 'zhin.js/command';
-import { getRouletteHelp } from "../../../lib/roulette-actions.js";
+import { resolveRouletteFlow } from "../../../lib/runtime.js";
+import { getRouletteHelp, normalizeRouletteAction } from "../../../lib/roulette-actions.js";
 import { runRouletteCommand } from "../../../lib/roulette-command.js";
 export default defineCommand({
     description: '俄罗斯轮盘：多人轮流开枪，中弹者输', descriptionI18n: { en: "Russian roulette: take turns; the player hit loses" },
     params: { action: { type: 'string', default: '' } },
     async execute(context) {
         const action = String(context.params.action ?? '');
-        const reply = await runRouletteCommand(context, context.input, action);
-        return reply ?? gameCommandFeedback(context, 'unknown', action) + '\n\n' + getRouletteHelp(context);
+        const normalized = normalizeRouletteAction(action);
+        if (normalized === 'help')
+            return getRouletteHelp(context);
+        if (!normalized)
+            return gameCommandFeedback(context, 'unknown', action) + '\n\n' + getRouletteHelp(context);
+        const flow = resolveRouletteFlow(context), player = gamePlayerFromInput(context.input, context);
+        await replyGameOperation({ session: flow.services.sessions, player, reply: context.session?.reply,
+            run: () => runRouletteCommand(context, context.input, action) });
     },
 });

package/lib/deadline-job.js

@@ -1,5 +1,5 @@
 import { outboundHostToken } from 'zhin.js';
-import { resolveLocale } from 'zhin.js/i18n';
+import { sendGameSessionMessage } from '@zhin.js/game-kit';
 import { expireOverdueSessions } from './game-flow.js';
 import { resolveRouletteFlow } from './runtime.js';
 /** Turn and lobby deadlines are checked every five seconds. */
@@ -28,16 +28,7 @@ function readOutbound(context) {
 async function announce(outbound, notice) {
     const session = notice.session;
     try {
-        await outbound.send({
-            locale: resolveLocale(session.locale),
-            adapter: session.adapter,
-            endpointKey: session.endpoint,
-            conversation: {
-                kind: session.channel_type,
-                id: session.channel_id,
-            },
-            content: notice.text,
-        });
+        await sendGameSessionMessage({ outbound, session, content: notice.text });
     }
     catch {
         // The result is already stored; a failed notice must not stop the other sessions.

package/lib/game-flow.d.ts

@@ -1,9 +1,9 @@
-import { type GameMessageLike } from '@zhin.js/game-kit';
+import { type GamePlayer } from '@zhin.js/game-kit';
 import type { RouletteConfig } from './config.js';
 import type { RouletteSessionRow } from './models.js';
 import type { MutePenaltyPort, PenaltyConversation } from './mute-penalty.js';
 import { type RouletteCommandAction } from './roulette-actions.js';
-import { type EndpointIdentity, type RouletteServices } from './session-service.js';
+import { type RouletteServices } from './session-service.js';
 /** Everything one action needs, resolved from the current runtime generation. */
 export interface RouletteFlow {
     readonly services: RouletteServices;
@@ -12,8 +12,7 @@ export interface RouletteFlow {
 }
 /** Who sent the action, from the runtime message. */
 export interface RouletteActor {
-    readonly message: GameMessageLike;
-    readonly endpoint: EndpointIdentity;
+    readonly message: GamePlayer;
     readonly roles: readonly string[];
 }
 export interface ExpiredSessionNotice {

package/lib/game-flow.js

@@ -1,5 +1,5 @@
 import { createMessages, resolveLocale } from 'zhin.js/i18n';
-import { gameCommandHint, GameSessionConflictError, SessionRevisionConflictError, channelKey } from '@zhin.js/game-kit';
+import { gameCommandHint, GameSessionConflictError, SessionRevisionConflictError, channelKey, gameTargetFromKey } from '@zhin.js/game-kit';
 import { RouletteRuleError, loserOf } from './engine.js';
 import { getRouletteHelp } from './roulette-actions.js';
 import { playerFromMessage, stateOf, } from './session-service.js';
@@ -8,25 +8,27 @@ const DEADLINE_ACTOR = 'deadline';
 const MANAGER_ROLES = ['master', 'trusted', 'owner', 'admin'];
 function noGame(message) { return messages(message.locale, 'noGame') + gameCommandHint(message, 'roulette', 'open'); }
 export async function runRouletteAction(flow, actor, action) {
-    const message = actor.message;
-    const locale = resolveLocale(message.locale);
-    if (action === 'help')
-        return getRouletteHelp(message);
-    if (message.$channel.type === 'private')
-        return messages(locale, 'text1');
-    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');
+    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 = [];
+            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) {
@@ -34,14 +36,16 @@ export async function expireOverdueSessions(flow, now, onNotice) {
     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);
+            await flow.services.sessions.runInScope({ scope: session.channel_key, run: async () => {
+                    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.
@@ -67,7 +71,7 @@ async function handleGameAction(flow, actor, action, session) {
     if (!gameAction)
         return noGame(message);
     try {
-        const result = await flow.services.sessions.applyAction(session, message.$sender.id, gameAction, flow.config);
+        const result = await flow.services.sessions.applyAction(session, message.sender.id, gameAction, flow.config);
         return describeResult(flow, gameAction, result, message);
     }
     catch (error) {
@@ -86,7 +90,7 @@ async function openLobby(flow, actor, session) {
         return messages(locale, 'text4', { p0: describeStatus(stateOf(session), flow.config, { ...actor.message, locale }) });
     }
     try {
-        const created = await flow.services.sessions.createLobby(actor.message, actor.endpoint, flow.config);
+        const created = await flow.services.sessions.createLobby(actor.message, flow.config);
         return describeLobby(stateOf(created), flow.config, { ...actor.message, locale });
     }
     catch (error) {
@@ -165,7 +169,7 @@ async function applyLoserPenalty(flow, session, state, penaltyEnabled) {
 async function handlePenaltySetting(flow, actor, action) {
     const message = actor.message;
     const locale = resolveLocale(message.locale);
-    if (message.$channel.type !== 'group')
+    if (message.target.kind !== 'group')
         return messages(locale, 'text9');
     const key = channelKey(message);
     const settings = flow.services.settings;
@@ -177,13 +181,13 @@ async function handlePenaltySetting(flow, actor, action) {
     if (!isManager(actor.roles))
         return messages(locale, 'text10');
     if (action === 'penalty-off') {
-        await settings.setMutePenalty(key, false, message.$sender.id);
+        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);
+    await settings.setMutePenalty(key, true, message.sender.id);
     return messages(locale, 'text13', { p0: flow.config.muteSeconds });
 }
 function describePenaltyStatus(enabled, supported, config, locale) {
@@ -206,7 +210,7 @@ function toGameAction(action, message) {
     return null;
 }
 function mayCancel(session, message, senderRoles) {
-    if (stateOf(session).hostId === message.$sender.id)
+    if (stateOf(session).hostId === message.sender.id)
         return true;
     return isManager(senderRoles);
 }
@@ -217,19 +221,17 @@ 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,
-    };
+    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) {
     return {
-        endpointAdapter: actor.endpoint.adapter,
-        endpointId: actor.endpoint.id,
-        kind: actor.message.$channel.type,
-        id: actor.message.$channel.id,
+        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({

package/lib/index.d.ts

@@ -4,5 +4,5 @@ export { expireOverdueSessions, runRouletteAction, type RouletteActor, type Roul
 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';
+export { rouletteServicesToken, resolveRouletteFlow } from './runtime.js';
+export { RouletteGroupSettings, RouletteSessionService, createServices, type RouletteServices, } from './session-service.js';

package/lib/index.js

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

package/lib/mute-penalty.js

@@ -1,4 +1,4 @@
-import { adapterFeatureId, resolveEndpointManagement } from 'zhin.js/adapter';
+import { adapterFeatureId } from 'zhin.js/adapter';
 export function resolveMutePenalty(context) {
     return {
         support(conversation) {
@@ -11,25 +11,25 @@ export function resolveMutePenalty(context) {
             if (!muteGroupMember) {
                 throw new Error('This Endpoint cannot mute group members');
             }
-            await muteGroupMember(conversation.id, userId, durationSeconds);
+            await muteGroupMember({ groupId: conversation.id, userId, durationSeconds });
         },
     };
 }
-/** project(adapterFeatureId) → connection(adapter, endpointId) → resolveEndpointManagement → muteGroupMember. */
+/** Resolve canonical identity, then capture its guarded management port from the same Index. */
 function findMuteGroupMember(context, conversation) {
     const adapters = readAdapterProjection(context);
     if (!adapters)
         return undefined;
     if (!conversation.endpointAdapter || !conversation.endpointId)
         return undefined;
-    let endpoint;
+    let management;
     try {
-        endpoint = adapters.connection(conversation.endpointAdapter, conversation.endpointId);
+        const id = adapters.resolve(conversation.endpointAdapter, conversation.endpointId);
+        management = id ? adapters.management(id) : undefined;
     }
     catch {
         return undefined;
     }
-    const management = resolveEndpointManagement(endpoint);
     const muteGroupMember = management?.muteGroupMember;
     if (typeof muteGroupMember !== 'function')
         return undefined;
@@ -47,7 +47,7 @@ function readAdapterProjection(context) {
     if (!projection || typeof projection !== 'object')
         return undefined;
     const lookup = projection;
-    if (typeof lookup.connection !== 'function')
+    if (typeof lookup.resolve !== 'function' || typeof lookup.management !== 'function')
         return undefined;
     return lookup;
 }

package/lib/roulette-actions.d.ts

@@ -1,6 +1,6 @@
-import type { GameMessageLike } from '@zhin.js/game-kit';
+import type { GamePlayer } from '@zhin.js/game-kit';
 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 function getRouletteHelp(message?: Pick<GameMessageLike, 'locale' | 'formatCommand'>): string;
+export declare function getRouletteHelp(message?: Pick<GamePlayer, 'locale' | 'formatCommand'>): string;
 export declare const ROULETTE_HELP: string;

package/lib/roulette-command.js

@@ -1,7 +1,7 @@
-import { messageFromCommandInput } from '@zhin.js/game-kit';
+import { gamePlayerFromInput } from '@zhin.js/game-kit';
 import { runRouletteAction } from './game-flow.js';
 import { normalizeRouletteAction, getRouletteHelp } from './roulette-actions.js';
-import { endpointOf, resolveRouletteFlow, senderRolesOf } from './runtime.js';
+import { 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.
@@ -11,11 +11,10 @@ export async function runRouletteCommand(context, input, rawAction) {
     if (!action)
         return null;
     if (action === 'help')
-        return getRouletteHelp(messageFromCommandInput(input, context));
+        return getRouletteHelp(gamePlayerFromInput(input, context));
     const flow = resolveRouletteFlow(context);
     const actor = {
-        message: messageFromCommandInput(input, context),
-        endpoint: endpointOf(input),
+        message: gamePlayerFromInput(input, context),
         roles: senderRolesOf(input),
     };
     return runRouletteAction(flow, actor, action);

package/lib/runtime.d.ts

@@ -2,7 +2,7 @@ import type { Locale } from 'zhin.js/i18n';
 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';
+import type { 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. */
@@ -15,5 +15,3 @@ export interface RouletteCapabilityContext extends AdapterProjectionContext {
 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

@@ -22,19 +22,3 @@ export function senderRolesOf(input) {
         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

@@ -1,14 +1,9 @@
 import type { Database, Models } from '@zhin.js/core';
-import { VersionedSessionService, type GameMessageLike } from '@zhin.js/game-kit';
+import { VersionedSessionService, type GamePlayer } 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;
@@ -36,7 +31,7 @@ export interface RouletteServiceOptions {
 export declare class RouletteSessionService extends VersionedSessionService<RouletteSessionRow> {
     #private;
     constructor(database: RouletteDatabase, options?: RouletteServiceOptions);
-    createLobby(message: GameMessageLike, endpoint: EndpointIdentity, config: RouletteConfig): Promise<RouletteSessionRow>;
+    createLobby(message: GamePlayer, 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>;
@@ -56,4 +51,4 @@ export interface RouletteServices {
 }
 export declare function createServices(database: RouletteDatabase, options?: RouletteServiceOptions): RouletteServices;
 export declare function stateOf(session: RouletteSessionRow): RouletteState;
-export declare function playerFromMessage(message: GameMessageLike): RoulettePlayer;
+export declare function playerFromMessage(message: GamePlayer): RoulettePlayer;

package/lib/session-service.js

@@ -1,4 +1,5 @@
-import { VersionedSessionService, channelKey, generateCompactId, secureRandomInt, } from '@zhin.js/game-kit';
+import { encodeStorageIdentity } from 'zhin.js/plugin-runtime';
+import { VersionedSessionService, 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;
@@ -11,30 +12,28 @@ export class RouletteSessionService extends VersionedSessionService {
         });
         this.#chooseBulletChamber = options.chooseBulletChamber ?? secureRandomInt;
     }
-    async createLobby(message, endpoint, config) {
+    async createLobby(message, config) {
         const now = Date.now();
         const host = playerFromMessage(message);
         const state = createLobby(host, tableRules(config));
         return this.createRow({
-            id: generateCompactId('rlt_'),
-            locale: message.locale ?? 'zh-CN',
-            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,
+            target: message.target,
+            fields: {
+                id: generateCompactId('rlt_'),
+                locale: message.locale ?? 'zh-CN',
+                endpoint_adapter: encodeStorageIdentity(message.target.endpoint.adapter),
+                endpoint_id: encodeStorageIdentity(message.target.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. */
@@ -121,8 +120,8 @@ 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 };
+    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 };

package/lib/view.d.ts

@@ -1,7 +1,7 @@
-import type { GameMessageLike } from '@zhin.js/game-kit';
+import type { GamePlayer } from '@zhin.js/game-kit';
 import type { RouletteConfig } from './config.js';
 import { type RoulettePlayer, type RouletteState } from './engine.js';
-type Presentation = Pick<GameMessageLike, 'locale' | 'formatCommand'>;
+type Presentation = Pick<GamePlayer, 'locale' | 'formatCommand'>;
 export declare const ROULETTE_TITLE: string;
 export declare function describeLobby(state: RouletteState, config: RouletteConfig, presentation?: Presentation): string;
 export declare function describeRoundStart(state: RouletteState, config: RouletteConfig, presentation?: Presentation): string;

package/middlewares/roulette-alias/index.js

@@ -1,10 +1,23 @@
 // Generated by build-plugin-runtime-entries.mjs. Do not edit.
-import { defineGameCommandAliasMiddleware } from '@zhin.js/game-kit';
+import { defineGameCommandAliasMiddleware, gamePlayerFromInput, replyGameOperation } from '@zhin.js/game-kit';
+import { normalizeRouletteAction, getRouletteHelp } from "../../lib/roulette-actions.js";
+import { resolveRouletteFlow } from "../../lib/runtime.js";
 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);
+        const normalized = normalizeRouletteAction(action);
+        if (!normalized)
+            return false;
+        if (normalized === 'help') {
+            await context.input.$reply(getRouletteHelp({ locale: context.input.locale,
+                formatCommand: path => context.input.formatCommand?.(path, context.owner.id) }));
+            return true;
+        }
+        const flow = resolveRouletteFlow(context), player = gamePlayerFromInput(input);
+        await replyGameOperation({ session: flow.services.sessions, player, reply: content => context.input.$reply(content),
+            run: () => runRouletteCommand(context, input, action) });
+        return true;
     },
 });

package/middlewares/roulette-fire/index.js

@@ -1,5 +1,5 @@
 // Generated by build-plugin-runtime-entries.mjs. Do not edit.
-import { channelKey, messageFromCommandInput } from '@zhin.js/game-kit';
+import { channelKey, gamePlayerFromInput, replyGameOperation } from '@zhin.js/game-kit';
 import { defineMiddleware } from 'zhin.js/middleware';
 import { runRouletteCommand } from "../../lib/roulette-command.js";
 import { rouletteServicesToken } from "../../lib/runtime.js";
@@ -11,20 +11,23 @@ const FIRE_WORDS = ['开枪', '扣动扳机'];
 export default defineMiddleware({
     target: 'inbound',
     async handle(context, next) {
+        if (!context.input.sender?.id) {
+            await next();
+            return;
+        }
         const text = context.input.content?.trim() ?? '';
         if (!FIRE_WORDS.includes(text)) {
             await next();
             return;
         }
-        const message = messageFromCommandInput(context.input);
+        const message = gamePlayerFromInput(context.input);
         const services = context.use(rouletteServicesToken);
         const session = await services.sessions.getActiveByChannel(channelKey(message));
-        if (!session || session.turn !== message.$sender.id) {
+        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);
+        await replyGameOperation({ session: services.sessions, player: message, reply: content => context.input.$reply(content),
+            run: () => runRouletteCommand(context, context.input, 'fire') });
     },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/plugin-roulette",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Zhin.js 俄罗斯轮盘 — 多人轮流开枪，可按群开启禁言惩罚 (Plugin Runtime)",
   "type": "module",
   "main": "./lib/index.js",
@@ -30,15 +30,15 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@zhin.js/core": "1.1.52",
-    "@zhin.js/game-kit": "1.1.17"
+    "@zhin.js/core": "1.1.54",
+    "@zhin.js/game-kit": "1.1.19"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
     "vitest": "^4.1.10",
-    "@zhin.js/schedule-feature": "1.1.9",
-    "@zhin.js/testing": "1.0.6",
-    "zhin.js": "1.1.17"
+    "@zhin.js/schedule-feature": "1.1.10",
+    "@zhin.js/testing": "1.0.7",
+    "zhin.js": "1.1.19"
   },
   "repository": {
     "type": "git",
@@ -79,10 +79,10 @@
     "plugins": []
   },
   "peerDependencies": {
-    "@zhin.js/command": "^1.1.11",
-    "@zhin.js/middleware": "^1.1.10",
-    "zhin.js": "^1.1.17",
-    "@zhin.js/schedule-feature": "^1.1.9"
+    "@zhin.js/command": "^1.1.12",
+    "@zhin.js/middleware": "^1.1.11",
+    "zhin.js": "^1.1.19",
+    "@zhin.js/schedule-feature": "^1.1.10"
   },
   "peerDependenciesMeta": {
     "@zhin.js/command": {