@zhin.js/adapter-napcat 1.1.18 → 1.1.20

package/lib/ws-endpoint.js

@@ -3,32 +3,42 @@ import { EndpointDeliveryError } from '@zhin.js/im-contract';
  * NapCat WS client endpoint — outbound connect to NapCat.
  */
 import WebSocket from 'ws';
-import { Endpoint, createRecallEndpointControl, createEndpointLifecycle, } from 'zhin.js/adapter';
+import { createEndpointSpecification, endpointSpec, createRecallEndpointControl, createEndpointLifecycle, } from 'zhin.js/adapter';
 import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
 import { createNapCatEndpointManagement } from './endpoint-management.js';
 import { InboundMessageDeduper, isNapCatBotMentioned, isSelfMessage, normalizeMessage, } from './napcat-inbound.js';
 import { buildSendAction, buildWsConnectOptions, formatInboundContent, formatOutboundSegments, isMessageEvent, napcatInboundConversation, napcatOutboundTarget, senderNickname, senderUserId, } from './protocol.js';
 import { receiveNapCatSideEvent } from './side-event-dispatch.js';
-import { callNapCatWsAction, handleNapCatWsMessage, rejectAllPending, } from './ws-transport.js';
 import { createNapCatContentPort } from './onebot-get-msg.js';
 import { NapcatClient } from './client.js';
-export class NapCatWsEndpoint extends Endpoint {
-    client = new NapcatClient((action, params) => this.#callApi(action, params));
+export class NapCatWsEndpoint extends NapcatClient {
+    [endpointSpec];
     #logger;
     #options;
     #inboundDeduper = new InboundMessageDeduper();
-    management = createNapCatEndpointManagement(this.client);
-    control = createRecallEndpointControl((id) => this.recallMessage(id));
-    content = createNapCatContentPort((action, params) => this.client.callApi(action, params));
+    #management = createNapCatEndpointManagement(this);
+    #control = createRecallEndpointControl((id, signal) => this.#recallMessage(id, signal));
+    #content = createNapCatContentPort(request => this.requestApi(request));
     #lifecycle;
-    #ws;
-    #requestId = { value: 0 };
-    #pending = new Map();
     #open = false;
     constructor(options) {
-        super();
+        super({ config: options.config, signal: options.signal });
         this.#logger = getAdapterLogger('napcat', options.config.id);
         this.#options = options;
+        const readTransportState = () => this.#transportState;
+        this[endpointSpec] = createEndpointSpecification(this, {
+            name: options.config.id,
+            start: () => this.#start(), open: () => this.#openEndpoint(),
+            close: () => this.#close(), stop: () => this.#stop(),
+            send: request => this.#send(request),
+            management: this.#management, control: this.#control, content: this.#content,
+            get transportState() { return readTransportState(); },
+        });
+        this.on('event', event => {
+            void this[endpointSpec].events.run(() => this.#admit(event)).catch((error) => {
+                this.#logger.debug(formatCompact({ op: 'napcat_receive_failed', error: error instanceof Error ? error.message : String(error) }));
+            });
+        });
         this.#lifecycle = createEndpointLifecycle({
             name: options.config.id,
             heartbeat: { intervalMs: options.config.heartbeat_interval, watchdogMisses: 2 },
@@ -41,39 +51,42 @@ export class NapCatWsEndpoint extends Endpoint {
             },
         });
     }
-    get transportState() {
+    get #transportState() {
         return this.#lifecycle.state;
     }
-    async start() {
+    get actionSocket() {
+        return this.#lifecycle.state === 'open' ? this.transportSocket : undefined;
+    }
+    async #start() {
         if (this.#lifecycle.started)
             return;
         await this.#lifecycle.start((handle) => this.#connect(handle));
     }
-    open() {
+    #openEndpoint() {
         this.#open = true;
     }
-    close() {
+    #close() {
         this.#open = false;
     }
-    async stop() {
+    async #stop() {
         this.#open = false;
         await this.#lifecycle.stop();
-        rejectAllPending(this.#pending);
+        this.rpc.disconnect();
         this.#inboundDeduper.clear();
-        if (this.#ws) {
+        if (this.transportSocket) {
             try {
-                this.#ws.close();
+                this.transportSocket.close();
             }
             catch {
                 /* ignore */
             }
-            this.#ws = undefined;
+            this.transportSocket = undefined;
         }
     }
-    async send({ conversation, payload }) {
+    async #send({ conversation, payload, signal }) {
         const message = formatOutboundSegments(payload);
         const { action, params } = buildSendAction(napcatOutboundTarget(conversation), message);
-        const data = await this.client.callApi(action, params);
+        const data = await this.requestApi({ action, params, signal });
         const rawId = data?.message_id;
         if ((typeof rawId !== 'number' && typeof rawId !== 'string') || String(rawId).trim() === '' || (typeof rawId === 'number' && !Number.isFinite(rawId))) {
             throw new EndpointDeliveryError('delivery_unconfirmed', 'Message delivery is unconfirmed: platform returned no message_id', 'unknown');
@@ -87,26 +100,24 @@ export class NapCatWsEndpoint extends Endpoint {
         }));
         return messageId;
     }
-    async recallMessage(messageId) {
+    async #recallMessage(messageId, signal) {
         if (!messageId)
             return;
-        await this.client.callApi('delete_msg', { message_id: Number(messageId) });
-    }
-    #callApi(action, params = {}) {
-        return callNapCatWsAction(this.#lifecycle.state === 'open' ? this.#ws : undefined, this.#pending, this.#requestId, action, params);
+        await this.requestApi({ action: 'delete_msg', params: { message_id: Number(messageId) }, signal });
     }
     /** Test / internal: admit a parsed event when the endpoint is open. */
-    admit(ev) {
-        if (!this.#open)
+    #admit(ev) {
+        const nativeEvent = ev;
+        if (!this.#open && !this.#lifecycle.started)
             return;
-        void this.emitPlatform(napCatPlatformEventName(ev), ev).catch((error) => {
+        void this[endpointSpec].events.platform(napCatPlatformEventName(ev), ev).catch((error) => {
             this.#logger.warn(formatCompact({
                 op: 'napcat_platform_event_failed',
                 error: error instanceof Error ? error.message : String(error),
             }));
         });
         if (!isMessageEvent(ev)) {
-            receiveNapCatSideEvent((name, payload) => this.emit(name, payload), this.#options.config.id, this.client, ev, this.#logger);
+            receiveNapCatSideEvent((name, payload) => this[endpointSpec].events.emit(name, payload), this.#options.config.id, this, ev, this.#logger);
             return;
         }
         if (isSelfMessage(ev))
@@ -117,11 +128,13 @@ export class NapCatWsEndpoint extends Endpoint {
         if (Array.isArray(ev.message) || typeof ev.message === 'string') {
             ev = { ...ev, message: normalizeMessage(ev.message) };
         }
-        const conversation = napcatInboundConversation(String(this.#options.id), ev);
+        const conversation = { ...napcatInboundConversation(String(this.#options.id), ev), endpoint: this[endpointSpec].identity };
         const content = formatInboundContent(ev);
         const nickname = senderNickname(ev);
         const mentioned = isNapCatBotMentioned(ev);
-        void this.emit('message.receive', {
+        void this[endpointSpec].events.message({
+            event: nativeEvent,
+            ...(typeof nativeEvent.time === 'number' ? { platformSentAt: nativeEvent.time * 1000 } : {}),
             conversation,
             message: { conversation, id: msgId },
             content,
@@ -156,10 +169,10 @@ export class NapCatWsEndpoint extends Endpoint {
         await new Promise((resolve, reject) => {
             let settled = false;
             const ws = create(url, { headers });
-            this.#ws = ws;
+            this.transportSocket = ws;
             handle.onForceClose(() => {
-                if (this.#ws === ws) {
-                    rejectAllPending(this.#pending);
+                if (this.transportSocket === ws) {
+                    this.rpc.disconnect();
                 }
                 try {
                     ws.close();
@@ -169,7 +182,7 @@ export class NapCatWsEndpoint extends Endpoint {
                 }
             });
             ws.on('open', () => {
-                if (settled || this.#ws !== ws || !this.#lifecycle.started)
+                if (settled || this.transportSocket !== ws || !this.#lifecycle.started)
                     return;
                 settled = true;
                 if (!this.#options.config.access_token) {
@@ -198,24 +211,20 @@ export class NapCatWsEndpoint extends Endpoint {
                 resolve();
             });
             ws.on('pong', () => {
-                if (this.#ws === ws)
+                if (this.transportSocket === ws)
                     this.#lifecycle.notifyHeartbeatAck();
             });
             ws.on('message', (data) => {
-                if (this.#ws !== ws || ws.readyState !== 1 || !this.#lifecycle.started)
+                if (this.transportSocket !== ws || ws.readyState !== 1 || !this.#lifecycle.started)
                     return;
                 this.#lifecycle.notifyHeartbeatAck();
-                handleNapCatWsMessage(data, {
-                    endpointId: this.#options.config.id,
-                    pending: this.#pending,
-                    admit: (event) => this.admit(event),
-                });
+                this.rpc.receive(data, event => this.ingest(event));
             });
             ws.on('close', (code, reason) => {
-                if (this.#ws !== ws)
+                if (this.transportSocket !== ws)
                     return;
-                this.#ws = undefined;
-                rejectAllPending(this.#pending);
+                this.transportSocket = undefined;
+                this.rpc.disconnect();
                 const reasonStr = typeof reason === 'string'
                     ? reason
                     : Buffer.isBuffer(reason)
@@ -241,7 +250,7 @@ export class NapCatWsEndpoint extends Endpoint {
                 }
             });
             ws.on('error', (err) => {
-                if (this.#ws !== ws)
+                if (this.transportSocket !== ws)
                     return;
                 const error = err instanceof Error ? err : new Error(String(err));
                 this.#logger.warn(formatCompact({

package/lib/ws-transport.d.ts

@@ -1,13 +1,19 @@
-import { type NapCatEvent } from './protocol.js';
-import { type NapCatPendingAction, type NapCatWsSocket } from './ws-types.js';
-export declare function decodeWsPayload(data: unknown): string;
-export declare function handleNapCatWsMessage(data: unknown, options: {
+import { type PendingRpc, type PendingRpcRequest } from 'zhin.js/adapter';
+import type { NapCatActionResponse, NapCatEvent } from './protocol.js';
+import { type NapCatWsSocket } from './ws-types.js';
+export interface NapCatRpcOptions {
     readonly endpointId: string;
-    readonly pending: Map<string, NapCatPendingAction>;
-    readonly admit: (ev: NapCatEvent) => void;
-}): void;
-export declare function callNapCatWsAction(ws: NapCatWsSocket | undefined, pending: Map<string, NapCatPendingAction>, requestId: {
-    value: number;
-}, action: string, params: Record<string, unknown>): Promise<unknown>;
-export declare function startNapCatHeartbeat(ws: NapCatWsSocket | undefined, intervalMs: number, existingTimer?: NodeJS.Timeout): NodeJS.Timeout;
-export declare function rejectAllPending(pending: Map<string, NapCatPendingAction>, message?: string): void;
+    readonly signal?: AbortSignal;
+    /** Reads the lifecycle-selected socket; RPC does not open or reconnect it. */
+    readonly socket: () => NapCatWsSocket | undefined;
+}
+export interface NapCatRpc {
+    call(request: PendingRpcRequest): Promise<NapCatActionResponse>;
+    receive(data: unknown, ingest: (event: NapCatEvent) => void): void;
+    disconnect: PendingRpc<NapCatActionResponse>['disconnect'];
+    dispose(): void;
+    readonly pendingCount: number;
+}
+/** Native SDK and semantic ports share this Client's correlation and cancellation owner. */
+export declare function createNapCatRpc(options: NapCatRpcOptions): NapCatRpc;
+export declare function decodeWsPayload(data: unknown): string;

package/lib/ws-transport.js

@@ -1,8 +1,33 @@
-import { EndpointDeliveryError } from '@zhin.js/im-contract';
-import { clearInterval, clearTimeout, setInterval, setTimeout } from 'node:timers';
+import { createPendingRpc } from 'zhin.js/adapter';
 import { formatCompact, getLogger } from '@zhin.js/logger';
-import { WS_OPEN, } from './ws-types.js';
+import { WS_OPEN } from './ws-types.js';
 const logger = getLogger('napcat');
+/** Native SDK and semantic ports share this Client's correlation and cancellation owner. */
+export function createNapCatRpc(options) {
+    const pending = createPendingRpc({
+        signal: options.signal, requestPrefix: 'req_', timeoutMs: 30_000,
+        transport: () => { const socket = options.socket(); return socket?.readyState === WS_OPEN ? socket : undefined; },
+        serialize: request => JSON.stringify({ action: request.action, params: request.params ?? {}, echo: request.id }),
+    });
+    return Object.freeze({
+        call: pending.call, disconnect: pending.disconnect, dispose: pending.dispose,
+        get pendingCount() { return pending.pendingCount; },
+        receive(data, ingest) {
+            try {
+                const message = JSON.parse(decodeWsPayload(data));
+                if ('echo' in message && typeof message.echo === 'string') {
+                    pending.accept({ id: message.echo, value: message });
+                    return;
+                }
+                ingest(message);
+            }
+            catch (error) {
+                logger.warn(formatCompact({ op: 'napcat_parse_failed', endpoint: options.endpointId,
+                    error: error instanceof Error ? error.message : String(error) }));
+            }
+        },
+    });
+}
 export function decodeWsPayload(data) {
     if (typeof data === 'string')
         return data;
@@ -12,72 +37,3 @@ export function decodeWsPayload(data) {
         return new TextDecoder().decode(data);
     return String(data ?? '');
 }
-export function handleNapCatWsMessage(data, options) {
-    try {
-        const raw = decodeWsPayload(data);
-        const msg = JSON.parse(raw);
-        if ('echo' in msg && typeof msg.echo === 'string') {
-            const resp = msg;
-            const pending = options.pending.get(resp.echo);
-            if (pending) {
-                options.pending.delete(resp.echo);
-                clearTimeout(pending.timeout);
-                if (resp.status === 'ok')
-                    pending.resolve(resp.data);
-                else {
-                    pending.reject(new EndpointDeliveryError('platform_rejected', `API error [${resp.retcode}]: ${resp.message || resp.wording || 'unknown'}`, 'rejected'));
-                }
-            }
-            return;
-        }
-        options.admit(msg);
-    }
-    catch (error) {
-        logger.warn(formatCompact({
-            op: 'napcat_parse_failed',
-            endpoint: options.endpointId,
-            error: error instanceof Error ? error.message : String(error),
-        }));
-    }
-}
-export function callNapCatWsAction(ws, pending, requestId, action, params) {
-    if (!ws || ws.readyState !== WS_OPEN) {
-        return Promise.reject(new EndpointDeliveryError('endpoint_disconnected', 'WebSocket is not connected', 'not_sent'));
-    }
-    const echo = `req_${++requestId.value}`;
-    const req = { action, params, echo };
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            pending.delete(echo);
-            reject(new EndpointDeliveryError('endpoint_timeout', `API call timeout: ${action}`, 'unknown'));
-        }, 30_000);
-        pending.set(echo, { resolve, reject, timeout });
-        try {
-            ws.send(JSON.stringify(req));
-        }
-        catch (error) {
-            pending.delete(echo);
-            clearTimeout(timeout);
-            reject(error instanceof Error ? error : new Error(String(error)));
-        }
-    });
-}
-export function startNapCatHeartbeat(ws, intervalMs, existingTimer) {
-    if (existingTimer)
-        clearInterval(existingTimer);
-    return setInterval(() => {
-        try {
-            ws?.ping?.();
-        }
-        catch {
-            /* ignore */
-        }
-    }, intervalMs);
-}
-export function rejectAllPending(pending, message = 'Connection closed') {
-    for (const [, entry] of pending) {
-        clearTimeout(entry.timeout);
-        entry.reject(new EndpointDeliveryError('endpoint_disconnected', message, 'unknown'));
-    }
-    pending.clear();
-}

package/lib/ws-types.d.ts

@@ -10,8 +10,3 @@ export interface NapCatWsCreateOptions {
     readonly headers?: Record<string, string>;
 }
 export declare const WS_OPEN = 1;
-export interface NapCatPendingAction {
-    resolve: (value: unknown) => void;
-    reject: (err: Error) => void;
-    timeout: NodeJS.Timeout;
-}

package/lib/wss-endpoint.d.ts

@@ -1,29 +1,21 @@
 /**
  * NapCat reverse WSS endpoint — accepts inbound WebSocket from NapCat.
  */
-import { Endpoint, type EndpointControl, type EndpointManagement, type EndpointSendRequest, type EndpointTransportState } from 'zhin.js/adapter';
+import { endpointSpec, type Endpoint, type EndpointSpecification } from 'zhin.js/adapter';
 import type { HttpHost } from '@zhin.js/host-http';
 import type { CapabilityId } from 'zhin.js';
-import { type NapCatEvent, type NapCatWssConfig } from './protocol.js';
+import { type NapCatWssConfig } from './protocol.js';
 import { NapcatClient } from './client.js';
+import { type NapCatWsSocket } from './ws-types.js';
 export interface NapCatWssEndpointOptions {
     readonly id: CapabilityId;
+    readonly signal?: AbortSignal;
     readonly http: HttpHost;
     readonly config: NapCatWssConfig;
 }
-export declare class NapCatWssEndpoint extends Endpoint<NapcatClient> {
+export declare class NapCatWssEndpoint extends NapcatClient implements Endpoint {
     #private;
-    readonly client: NapcatClient;
-    readonly management: EndpointManagement;
-    readonly control: EndpointControl;
-    readonly content: import("@zhin.js/adapter").EndpointContentPort;
+    readonly [endpointSpec]: EndpointSpecification;
     constructor(options: NapCatWssEndpointOptions);
-    get transportState(): EndpointTransportState;
-    start(): Promise<void>;
-    open(): void;
-    close(): void;
-    stop(): Promise<void>;
-    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
-    recallMessage(messageId: string): Promise<void>;
-    admit(ev: NapCatEvent): void;
+    protected get actionSocket(): NapCatWsSocket | undefined;
 }

package/lib/wss-endpoint.js

@@ -2,7 +2,7 @@ import { EndpointDeliveryError } from '@zhin.js/im-contract';
 /**
  * NapCat reverse WSS endpoint — accepts inbound WebSocket from NapCat.
  */
-import { Endpoint, createEndpointLifecycle, createRecallEndpointControl, } from 'zhin.js/adapter';
+import { createEndpointSpecification, endpointSpec, createEndpointLifecycle, createRecallEndpointControl, } from 'zhin.js/adapter';
 import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
 import { createNapCatEndpointManagement } from './endpoint-management.js';
 import { InboundMessageDeduper, isNapCatBotMentioned, isSelfMessage, normalizeMessage, } from './napcat-inbound.js';
@@ -10,47 +10,60 @@ import { buildSendAction, formatInboundContent, formatOutboundSegments, isMessag
 import { receiveNapCatSideEvent } from './side-event-dispatch.js';
 import { createNapCatContentPort } from './onebot-get-msg.js';
 import { NapcatClient } from './client.js';
-import { callNapCatWsAction, handleNapCatWsMessage, rejectAllPending, } from './ws-transport.js';
 import { verifyNapCatAccessToken } from './wss-auth.js';
-export class NapCatWssEndpoint extends Endpoint {
-    client = new NapcatClient((action, params) => this.#callApi(action, params));
+export class NapCatWssEndpoint extends NapcatClient {
+    [endpointSpec];
     #logger;
     #options;
     #inboundDeduper = new InboundMessageDeduper();
-    management = createNapCatEndpointManagement(this.client);
-    control = createRecallEndpointControl((id) => this.recallMessage(id));
-    content = createNapCatContentPort((action, params) => this.client.callApi(action, params));
+    #management = createNapCatEndpointManagement(this);
+    #control = createRecallEndpointControl((id, signal) => this.#recallMessage(id, signal));
+    #content = createNapCatContentPort(request => this.requestApi(request));
     #connectionLifecycle;
-    #ws;
     #wsRelease;
     #connectionTask = Promise.resolve();
-    #requestId = { value: 0 };
-    #pending = new Map();
     #open = false;
     #started = false;
     #stopped = false;
     constructor(options) {
-        super();
+        super({ config: options.config, signal: options.signal });
         this.#logger = getAdapterLogger('napcat', options.config.id);
         this.#options = options;
+        const readTransportState = () => this.#transportState;
+        this[endpointSpec] = createEndpointSpecification(this, {
+            name: options.config.id,
+            start: () => this.#start(), open: () => this.#openEndpoint(),
+            close: () => this.#close(), stop: () => this.#stop(),
+            send: request => this.#send(request),
+            management: this.#management, control: this.#control, content: this.#content,
+            get transportState() { return readTransportState(); },
+        });
+        this.on('event', event => {
+            void this[endpointSpec].events.run(() => this.#admit(event)).catch((error) => {
+                this.#logger.debug(formatCompact({ op: 'napcat_receive_failed', error: error instanceof Error ? error.message : String(error) }));
+            });
+        });
         this.#connectionLifecycle = createEndpointLifecycle({
             name: `${options.config.id}:inbound`,
             reconnect: false,
             heartbeat: { intervalMs: options.config.heartbeat_interval, watchdogMisses: 2 },
         });
     }
-    get transportState() {
+    get #transportState() {
         if (this.#stopped)
             return 'stopped';
         if (!this.#started)
             return 'idle';
         if (this.#connectionLifecycle.state === 'closed')
             return 'closed';
-        if (this.#ws?.readyState === 1)
+        if (this.transportSocket?.readyState === 1)
             return 'open';
         return this.#connectionLifecycle.state === 'connecting' ? 'connecting' : 'idle';
     }
-    async start() {
+    get actionSocket() {
+        return this.#connectionLifecycle.state === 'closed' ? undefined : this.transportSocket;
+    }
+    async #start() {
         if (this.#started)
             return;
         this.#stopped = false;
@@ -74,53 +87,51 @@ export class NapCatWssEndpoint extends Endpoint {
             path: this.#options.config.path,
         }));
     }
-    open() {
+    #openEndpoint() {
         this.#open = true;
     }
-    close() {
+    #close() {
         this.#open = false;
     }
-    async stop() {
+    async #stop() {
         this.#stopped = true;
         this.#open = false;
         this.#wsRelease?.();
         this.#wsRelease = undefined;
         await this.#connectionTask;
         await this.#connectionLifecycle.stop();
-        rejectAllPending(this.#pending);
+        this.rpc.disconnect();
         this.#inboundDeduper.clear();
-        this.#ws = undefined;
+        this.transportSocket = undefined;
         this.#started = false;
     }
-    async send({ conversation, payload }) {
+    async #send({ conversation, payload, signal }) {
         const message = formatOutboundSegments(payload);
         const { action, params } = buildSendAction(napcatOutboundTarget(conversation), message);
-        const data = await this.client.callApi(action, params);
+        const data = await this.requestApi({ action, params, signal });
         const rawId = data?.message_id;
         if ((typeof rawId !== 'number' && typeof rawId !== 'string') || String(rawId).trim() === '' || (typeof rawId === 'number' && !Number.isFinite(rawId))) {
             throw new EndpointDeliveryError('delivery_unconfirmed', 'Message delivery is unconfirmed: platform returned no message_id', 'unknown');
         }
         return String(rawId);
     }
-    async recallMessage(messageId) {
+    async #recallMessage(messageId, signal) {
         if (!messageId)
             return;
-        await this.client.callApi('delete_msg', { message_id: Number(messageId) });
-    }
-    #callApi(action, params = {}) {
-        return callNapCatWsAction(this.#connectionLifecycle.state === 'closed' ? undefined : this.#ws, this.#pending, this.#requestId, action, params);
+        await this.requestApi({ action: 'delete_msg', params: { message_id: Number(messageId) }, signal });
     }
-    admit(ev) {
-        if (!this.#open)
+    #admit(ev) {
+        const nativeEvent = ev;
+        if (!this.#open && !this.#started)
             return;
-        void this.emitPlatform(napCatPlatformEventName(ev), ev).catch((error) => {
+        void this[endpointSpec].events.platform(napCatPlatformEventName(ev), ev).catch((error) => {
             this.#logger.warn(formatCompact({
                 op: 'napcat_platform_event_failed',
                 error: error instanceof Error ? error.message : String(error),
             }));
         });
         if (!isMessageEvent(ev)) {
-            receiveNapCatSideEvent((name, payload) => this.emit(name, payload), this.#options.config.id, this.client, ev, this.#logger);
+            receiveNapCatSideEvent((name, payload) => this[endpointSpec].events.emit(name, payload), this.#options.config.id, this, ev, this.#logger);
             return;
         }
         if (isSelfMessage(ev))
@@ -131,10 +142,12 @@ export class NapCatWssEndpoint extends Endpoint {
         if (Array.isArray(ev.message) || typeof ev.message === 'string') {
             ev = { ...ev, message: normalizeMessage(ev.message) };
         }
-        const conversation = napcatInboundConversation(String(this.#options.id), ev);
+        const conversation = { ...napcatInboundConversation(String(this.#options.id), ev), endpoint: this[endpointSpec].identity };
         const nickname = senderNickname(ev);
         const mentioned = isNapCatBotMentioned(ev);
-        void this.emit('message.receive', {
+        void this[endpointSpec].events.message({
+            event: nativeEvent,
+            ...(typeof nativeEvent.time === 'number' ? { platformSentAt: nativeEvent.time * 1000 } : {}),
             conversation,
             message: { conversation, id: msgId },
             content: formatInboundContent(ev),
@@ -173,12 +186,12 @@ export class NapCatWssEndpoint extends Endpoint {
         }
         const socket = connection.socket;
         await this.#connectionLifecycle.stop();
-        rejectAllPending(this.#pending, 'Connection replaced');
+        this.rpc.disconnect('Connection replaced');
         await this.#connectionLifecycle.start(async (lifecycleHandle) => {
-            this.#ws = socket;
+            this.transportSocket = socket;
             lifecycleHandle.onForceClose(() => {
-                if (this.#ws === socket) {
-                    rejectAllPending(this.#pending);
+                if (this.transportSocket === socket) {
+                    this.rpc.disconnect();
                 }
                 try {
                     socket.close();
@@ -196,29 +209,25 @@ export class NapCatWssEndpoint extends Endpoint {
                 }
             }, this.#options.config.heartbeat_interval);
             socket.on('pong', () => {
-                if (this.#ws === socket)
+                if (this.transportSocket === socket)
                     this.#connectionLifecycle.notifyHeartbeatAck();
             });
             socket.on('message', (data) => {
-                if (this.#ws !== socket || this.#connectionLifecycle.state === 'closed')
+                if (this.transportSocket !== socket || this.#connectionLifecycle.state === 'closed')
                     return;
                 this.#connectionLifecycle.notifyHeartbeatAck();
-                handleNapCatWsMessage(data, {
-                    endpointId: this.#options.config.id,
-                    pending: this.#pending,
-                    admit: (event) => this.admit(event),
-                });
+                this.rpc.receive(data, event => this.ingest(event));
             });
             socket.on('error', (error) => {
-                if (this.#ws !== socket)
+                if (this.transportSocket !== socket)
                     return;
                 this.#logger.warn(formatCompact({ op: 'ws_error', error: String(error) }));
             });
             socket.on('close', () => {
-                if (this.#ws !== socket)
+                if (this.transportSocket !== socket)
                     return;
-                this.#ws = undefined;
-                rejectAllPending(this.#pending);
+                this.transportSocket = undefined;
+                this.rpc.disconnect();
                 lifecycleHandle.notifyClosed(new Error('NapCat reverse WebSocket closed'));
             });
         });