@agentunion/fastaun-browser 0.5.9 → 0.5.11

package/dist/transport.js

@@ -4,9 +4,311 @@ import { isJsonObject } from './types.js';
 const MAX_WS_PAYLOAD_SIZE = 1_000_000;
 const MAX_RPC_INFLIGHT = 16;
 const MAX_BACKGROUND_RPC_INFLIGHT = 8;
+const WORKER_START_TIMEOUT_MS = 2_000;
+const WORKER_OPEN_TIMEOUT_MS = 2_000;
 const _noopLog = { error: () => { }, warn: () => { }, info: () => { }, debug: () => { } };
 /** RPC 请求递增计数器，避免 Date.now() 高并发碰撞 */
 let _rpcIdCounter = 0;
+const WORKER_WEBSOCKET_SOURCE = `
+let socket = null;
+self.postMessage({ type: 'ready' });
+self.onmessage = (event) => {
+  const command = event.data || {};
+  if (command.type === 'connect') {
+    try {
+      socket = new WebSocket(command.url);
+      socket.onopen = () => self.postMessage({ type: 'open' });
+      socket.onmessage = (message) => self.postMessage({ type: 'message', data: message.data });
+      socket.onerror = () => self.postMessage({ type: 'error', message: 'websocket error' });
+      socket.onclose = (close) => self.postMessage({
+        type: 'close', code: close.code, reason: close.reason || '', wasClean: close.wasClean === true,
+      });
+    } catch (error) {
+      self.postMessage({ type: 'error', message: error instanceof Error ? error.message : String(error) });
+    }
+    return;
+  }
+  if (command.type === 'send') {
+    try {
+      if (!socket || socket.readyState !== WebSocket.OPEN) throw new Error('websocket is not open');
+      socket.send(command.data);
+      self.postMessage({ type: 'send_result', id: command.id, ok: true });
+    } catch (error) {
+      self.postMessage({
+        type: 'send_result', id: command.id, ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+    return;
+  }
+  if (command.type === 'close' && socket) socket.close(command.code, command.reason);
+};
+`;
+class WorkerWebSocketProxy {
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSING = 2;
+    static CLOSED = 3;
+    readyState = WorkerWebSocketProxy.CONNECTING;
+    onopen = null;
+    onmessage = null;
+    onerror = null;
+    onclose = null;
+    _url;
+    _worker;
+    _workerUrl;
+    _nativeSocket = null;
+    _workerReady = false;
+    _opened = false;
+    _closedEventEmitted = false;
+    _workerStartTimer = null;
+    _workerOpenTimer = null;
+    _listeners = new Map();
+    _pendingSends = new Map();
+    _sendSeq = 0;
+    constructor(url) {
+        this._url = url;
+        this._workerUrl = URL.createObjectURL(new Blob([WORKER_WEBSOCKET_SOURCE], { type: 'text/javascript' }));
+        try {
+            this._worker = new Worker(this._workerUrl);
+        }
+        catch (error) {
+            URL.revokeObjectURL(this._workerUrl);
+            throw error;
+        }
+        const worker = this._worker;
+        worker.onmessage = (event) => this._handleWorkerMessage(event.data);
+        worker.onerror = (event) => {
+            event.preventDefault?.();
+            if (!this._opened) {
+                this._fallbackToNative();
+                return;
+            }
+            this._fallbackToNative(true);
+        };
+        this._workerStartTimer = globalThis.setTimeout(() => this._fallbackToNative(), WORKER_START_TIMEOUT_MS);
+    }
+    send(data) {
+        if (this.readyState !== WorkerWebSocketProxy.OPEN)
+            return Promise.reject(new Error('websocket is not open'));
+        if (this._nativeSocket) {
+            try {
+                this._nativeSocket.send(data);
+                return Promise.resolve();
+            }
+            catch (error) {
+                return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+        const worker = this._worker;
+        if (!worker)
+            return Promise.reject(new Error('websocket worker is not available'));
+        const id = ++this._sendSeq;
+        return new Promise((resolve, reject) => {
+            this._pendingSends.set(id, { resolve, reject });
+            try {
+                worker.postMessage({ type: 'send', id, data });
+            }
+            catch (error) {
+                this._pendingSends.delete(id);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    close(code, reason) {
+        if (this.readyState === WorkerWebSocketProxy.CLOSED)
+            return;
+        this.readyState = WorkerWebSocketProxy.CLOSING;
+        if (this._nativeSocket) {
+            try {
+                this._nativeSocket.close(code, reason);
+            }
+            catch {
+                this._emitClose(new CloseEvent('close', { code: code ?? 1000, reason: reason ?? '', wasClean: true }));
+            }
+            return;
+        }
+        if (!this._workerReady || !this._worker) {
+            this._disposeWorker();
+            this._emitClose(new CloseEvent('close', { code: code ?? 1000, reason: reason ?? '', wasClean: true }));
+            return;
+        }
+        try {
+            this._worker.postMessage({ type: 'close', code, reason });
+        }
+        catch {
+            this._fallbackToNative();
+        }
+    }
+    addEventListener(type, listener) {
+        const callback = typeof listener === 'function' ? listener : (event) => listener.handleEvent(event);
+        const listeners = this._listeners.get(type) ?? new Set();
+        listeners.add(callback);
+        this._listeners.set(type, listeners);
+    }
+    removeEventListener(type, listener) {
+        if (typeof listener === 'function')
+            this._listeners.get(type)?.delete(listener);
+    }
+    _handleWorkerMessage(reply) {
+        if (reply.type === 'ready') {
+            if (this._workerReady || !this._worker)
+                return;
+            this._workerReady = true;
+            this._clearWorkerStartTimer();
+            try {
+                this._worker.postMessage({ type: 'connect', url: this._url });
+                this._workerOpenTimer = globalThis.setTimeout(() => this._fallbackToNative(), WORKER_OPEN_TIMEOUT_MS);
+            }
+            catch {
+                this._fallbackToNative();
+            }
+            return;
+        }
+        if (reply.type === 'send_result' && reply.id !== undefined) {
+            const pending = this._pendingSends.get(reply.id);
+            if (!pending)
+                return;
+            this._pendingSends.delete(reply.id);
+            if (reply.ok)
+                pending.resolve();
+            else
+                pending.reject(new Error(reply.error || 'websocket send failed'));
+            return;
+        }
+        if (reply.type === 'open') {
+            this._clearWorkerOpenTimer();
+            this._opened = true;
+            this.readyState = WorkerWebSocketProxy.OPEN;
+            const event = new Event('open');
+            this.onopen?.(event);
+            this._emit('open', event);
+            return;
+        }
+        if (reply.type === 'message') {
+            const event = new MessageEvent('message', { data: reply.data });
+            this.onmessage?.(event);
+            this._emit('message', event);
+            return;
+        }
+        if (reply.type === 'error') {
+            if (!this._opened && this.readyState === WorkerWebSocketProxy.CONNECTING) {
+                this._fallbackToNative();
+                return;
+            }
+            this._emitError(reply.message || 'websocket worker error');
+            return;
+        }
+        if (reply.type === 'close') {
+            if (!this._opened && this.readyState === WorkerWebSocketProxy.CONNECTING) {
+                this._fallbackToNative();
+                return;
+            }
+            this._emitClose(new CloseEvent('close', {
+                code: reply.code ?? 1006, reason: reply.reason ?? '', wasClean: reply.wasClean === true,
+            }));
+        }
+    }
+    _fallbackToNative(force = false) {
+        if (this._nativeSocket || this.readyState === WorkerWebSocketProxy.CLOSED)
+            return;
+        if (!force && (this.readyState !== WorkerWebSocketProxy.CONNECTING || this._opened))
+            return;
+        const wasOpened = this._opened;
+        this._opened = false;
+        this.readyState = WorkerWebSocketProxy.CONNECTING;
+        this._disposeWorker();
+        try {
+            const socket = new WebSocket(this._url);
+            this._nativeSocket = socket;
+            socket.onopen = (event) => {
+                this._opened = true;
+                this.readyState = WorkerWebSocketProxy.OPEN;
+                if (!wasOpened) {
+                    this.onopen?.(event);
+                    this._emit('open', event);
+                }
+            };
+            socket.onmessage = (event) => {
+                this.onmessage?.(event);
+                this._emit('message', event);
+            };
+            socket.onerror = (event) => {
+                this.onerror?.(event);
+                this._emit('error', event);
+            };
+            socket.onclose = (event) => this._emitClose(event);
+        }
+        catch (error) {
+            this.readyState = WorkerWebSocketProxy.CLOSED;
+            this._emitError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    _emitClose(event) {
+        if (this._closedEventEmitted)
+            return;
+        this._closedEventEmitted = true;
+        this.readyState = WorkerWebSocketProxy.CLOSED;
+        for (const pending of this._pendingSends.values())
+            pending.reject(new Error('websocket closed'));
+        this._pendingSends.clear();
+        this.onclose?.(event);
+        this._emit('close', event);
+        this._disposeWorker();
+        this._nativeSocket = null;
+    }
+    _clearWorkerStartTimer() {
+        if (this._workerStartTimer === null)
+            return;
+        globalThis.clearTimeout(this._workerStartTimer);
+        this._workerStartTimer = null;
+    }
+    _clearWorkerOpenTimer() {
+        if (this._workerOpenTimer === null)
+            return;
+        globalThis.clearTimeout(this._workerOpenTimer);
+        this._workerOpenTimer = null;
+    }
+    _disposeWorker() {
+        this._clearWorkerStartTimer();
+        this._clearWorkerOpenTimer();
+        for (const pending of this._pendingSends.values())
+            pending.reject(new Error('websocket worker unavailable'));
+        this._pendingSends.clear();
+        const worker = this._worker;
+        this._worker = null;
+        if (worker) {
+            worker.onmessage = null;
+            worker.onerror = null;
+            worker.terminate();
+        }
+        const workerUrl = this._workerUrl;
+        this._workerUrl = null;
+        if (workerUrl && typeof URL.revokeObjectURL === 'function')
+            URL.revokeObjectURL(workerUrl);
+    }
+    _emitError(message) {
+        const event = new ErrorEvent('error', { message });
+        this.onerror?.(event);
+        this._emit('error', event);
+    }
+    _emit(type, event) {
+        for (const listener of [...(this._listeners.get(type) ?? [])])
+            listener(event);
+    }
+}
+export function createTransportWebSocket(url) {
+    if (typeof Worker === 'function' && typeof Blob === 'function' && typeof URL !== 'undefined'
+        && typeof URL.createObjectURL === 'function' && typeof URL.revokeObjectURL === 'function') {
+        try {
+            return new WorkerWebSocketProxy(url);
+        }
+        catch {
+            // Worker/CSP 不可用时保持原生 WebSocket 路径。
+        }
+    }
+    return new WebSocket(url);
+}
 // ── Trace 树状展示 ─────────────────────────────────────────────
 const TRACE_SPAN_DETAIL_FIELDS = [
     'method', 'route', 'namespace', 'instance_id', 'aid', 'caller_aid',
@@ -260,6 +562,10 @@ export class RPCTransport {
     _traceMode = 'off';
     // Trace observer：observer(traceInfo) 在每次 RPC/事件携带 _trace 时调用
     _traceObserver = null;
+    // 每个 transport 实例一个轻量级网络 actor。命令只在此处启动网络操作，
+    // 不等待 RPC 响应，避免应用回调中的 send 反向占住收包路径。
+    _actorTail = Promise.resolve();
+    _actorBusy = false;
     constructor(opts) {
         this._dispatcher = opts.eventDispatcher;
         this._timeout = opts.timeout ?? 10;
@@ -287,18 +593,21 @@ export class RPCTransport {
     setMetaObserver(observer) {
         this._metaObserver = observer;
     }
-    async _notifyMetaObserver(message) {
-        if (this._metaObserver === null)
+    _notifyMetaObserver(message) {
+        const observer = this._metaObserver;
+        if (observer === null)
             return;
         const meta = message._meta;
         if (!isJsonObject(meta))
             return;
-        try {
-            await this._metaObserver(meta);
-        }
-        catch (exc) {
-            this._log.debug(`meta_observer raised: ${String(exc)}`);
-        }
+        this._dispatcher.enqueueTask(async () => {
+            try {
+                await observer(meta);
+            }
+            catch (exc) {
+                this._log.debug(`meta_observer raised: ${String(exc)}`);
+            }
+        });
     }
     /** 设置 trace 模式：off / log / diag */
     setTraceMode(mode) {
@@ -335,7 +644,10 @@ export class RPCTransport {
      * 连接到 WebSocket URL。
      * 等待首条消息，若为 challenge 则返回，否则进入消息路由。
      */
-    async connect(url) {
+    connect(url) {
+        return this._enqueueActorStart(() => this._connectImpl(url));
+    }
+    async _connectImpl(url) {
         const tStart = Date.now();
         this._log.debug(`connect enter: url=${url}`);
         const setup = await this._withConnectionSetup(async () => {
@@ -345,7 +657,7 @@ export class RPCTransport {
             this._lastCloseCode = null;
             this._lastCloseReason = '';
             const handshake = new Promise((resolve, reject) => {
-                const ws = new WebSocket(url);
+                const ws = createTransportWebSocket(url);
                 this._ws = ws;
                 this._closed = false;
                 let initialResolved = false;
@@ -489,7 +801,10 @@ export class RPCTransport {
         return setup.handshake;
     }
     /** 关闭连接 */
-    async close() {
+    close() {
+        return this._enqueueActor(() => this._closeImpl());
+    }
+    async _closeImpl() {
         await this._withConnectionSetup(() => this._closeUnlocked());
     }
     /** 已持有连接建立串行权时关闭当前 WebSocket。 */
@@ -566,7 +881,10 @@ export class RPCTransport {
      * 发起 JSON-RPC 2.0 调用。
      * 返回 result 字段的值；若有 error 字段则抛出映射后的错误。
      */
-    async call(method, params, timeout, trace, background = false) {
+    call(method, params, timeout, trace, background = false) {
+        return this._enqueueActorStart(() => this._callImpl(method, params, timeout, trace, background), () => new TimeoutError(`rpc cancelled: ${method}`, { retryable: true }));
+    }
+    _callImpl(method, params, timeout, trace, background = false) {
         if (this._closed || !this._ws) {
             throw this._notConnectedError();
         }
@@ -612,7 +930,7 @@ export class RPCTransport {
                 this._drainRpcQueue();
             }, effectiveTimeout);
             const pending = {
-                resolve: async (response) => {
+                resolve: (response) => {
                     clearTimeout(timer);
                     const elapsed = Date.now() - tStart;
                     if (response.error !== undefined) {
@@ -631,7 +949,7 @@ export class RPCTransport {
                         if (traceId) {
                             this._log.info(`[trace=${traceId}] rpc_recv method=${method} rpc_id=${rpcId} duration_ms=${elapsed} status=ok`);
                         }
-                        await this._notifyMetaObserver(response);
+                        this._notifyMetaObserver(response);
                         // 处理 success 路径的 _trace
                         const respTrace = response._trace;
                         if (respTrace && typeof respTrace === 'object' && !Array.isArray(respTrace)) {
@@ -671,7 +989,10 @@ export class RPCTransport {
         return Object.assign(promise, { cancel: () => cancelRpc?.() });
     }
     /** 发送 JSON-RPC 2.0 Notification，不分配 id，也不等待响应。 */
-    async notify(method, params) {
+    notify(method, params) {
+        return this._enqueueActorStart(() => this._notifyImpl(method, params));
+    }
+    async _notifyImpl(method, params) {
         if (this._closed || !this._ws) {
             throw this._notConnectedError();
         }
@@ -699,6 +1020,63 @@ export class RPCTransport {
         this._sendChain = run.catch(() => { });
         return run;
     }
+    _enqueueActor(operation) {
+        this._actorBusy = true;
+        const run = this._actorTail.then(async () => {
+            return await operation();
+        }, async () => {
+            return await operation();
+        });
+        const tail = run.then(() => undefined, () => undefined);
+        this._actorTail = tail;
+        void tail.then(() => {
+            if (this._actorTail === tail)
+                this._actorBusy = false;
+        });
+        return run;
+    }
+    _enqueueActorStart(operation, cancellationError) {
+        let resolveResult;
+        let rejectResult;
+        const result = new Promise((resolve, reject) => { resolveResult = resolve; rejectResult = reject; });
+        let cancel;
+        let cancelRequested = false;
+        const launch = () => {
+            if (cancelRequested)
+                return;
+            try {
+                const inner = operation();
+                cancel = inner.cancel;
+                inner.then(resolveResult, rejectResult);
+            }
+            catch (err) {
+                rejectResult(err);
+            }
+        };
+        if (this._actorBusy) {
+            const gate = this._actorTail.then(launch, launch);
+            const tail = gate.then(() => undefined, () => undefined);
+            this._actorTail = tail;
+            void tail.then(() => {
+                if (this._actorTail === tail)
+                    this._actorBusy = false;
+            });
+        }
+        else {
+            launch();
+        }
+        return Object.assign(result, {
+            cancel: () => {
+                if (cancelRequested)
+                    return;
+                cancelRequested = true;
+                if (cancel)
+                    cancel();
+                else
+                    rejectResult(cancellationError?.() ?? new TimeoutError('rpc cancelled', { retryable: true }));
+            },
+        });
+    }
     _sendText(payload, context, beforeSend) {
         return this._enqueueSend(async () => {
             if (beforeSend && !beforeSend()) {
@@ -709,7 +1087,7 @@ export class RPCTransport {
             }
             const ws = this._ws;
             try {
-                ws.send(payload);
+                await Promise.resolve(ws.send(payload));
             }
             catch (err) {
                 throw await this._sendFailureError(context, err, ws);
@@ -841,7 +1219,15 @@ export class RPCTransport {
             const enriched = { ...respTrace, spans };
             this._log.info(traceDisplay(method, status, elapsedMs, respTrace, spans));
             if (this._traceObserver !== null) {
-                this._traceObserver({ type: 'rpc', method, trace: enriched, status, duration_ms: elapsedMs });
+                const observer = this._traceObserver;
+                this._dispatcher.enqueueTask(async () => {
+                    try {
+                        await observer({ type: 'rpc', method, trace: enriched, status, duration_ms: elapsedMs });
+                    }
+                    catch (err) {
+                        this._log.debug(`trace observer raised: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                });
             }
         }
         catch (err) {
@@ -887,10 +1273,18 @@ export class RPCTransport {
         // 非主动关闭时触发断线回调
         if (!wasClosed) {
             const error = new ConnectionError(`websocket closed: code=${event.code} reason=${event.reason}`);
-            this._dispatcher.publish('connection.error', { error });
             if (this._onDisconnect) {
-                this._onDisconnect(error, event.code).catch(exc => this._log.warn('[aun_core.transport] disconnect callback exception:', exc));
+                const onDisconnect = this._onDisconnect;
+                this._dispatcher.enqueueTask(async () => {
+                    try {
+                        await onDisconnect(error, event.code);
+                    }
+                    catch (exc) {
+                        this._log.warn('[aun_core.transport] disconnect callback exception:', exc);
+                    }
+                });
             }
+            this._dispatcher.enqueue('connection.error', { error });
         }
     }
     _notConnectedError() {
@@ -922,7 +1316,7 @@ export class RPCTransport {
         if (method === 'challenge') {
             this._challenge = message;
             this._log.debug('challenge received');
-            this._dispatcher.publish('connection.challenge', message.params ?? {});
+            this._dispatcher.enqueue('connection.challenge', message.params ?? {});
             return;
         }
         // 事件推送
@@ -930,7 +1324,7 @@ export class RPCTransport {
             const protocolEvent = method.slice(6);
             const sdkEvent = EVENT_NAME_MAP[protocolEvent] ?? protocolEvent;
             this._log.debug(`event recv: event=${sdkEvent} ${summarizeDict(message.params, DIAG_RESULT_FIELDS)}`);
-            void this._notifyMetaObserver(message);
+            this._notifyMetaObserver(message);
             // 提取事件中的 _trace 并回调 observer，然后从 params 中剥离
             const params = (message.params ?? {});
             if ('_trace' in params) {
@@ -938,10 +1332,14 @@ export class RPCTransport {
                 delete params._trace;
                 if (eventTrace && typeof eventTrace === 'object' && !Array.isArray(eventTrace)) {
                     if (this._traceObserver !== null) {
-                        try {
-                            this._traceObserver({ type: 'event', event: sdkEvent, trace: eventTrace });
-                        }
-                        catch { /* observer 抛错被吞 */ }
+                        const observer = this._traceObserver;
+                        const tracePayload = eventTrace;
+                        this._dispatcher.enqueueTask(async () => {
+                            try {
+                                await observer({ type: 'event', event: sdkEvent, trace: tracePayload });
+                            }
+                            catch { /* observer 抛错被吞 */ }
+                        });
                     }
                     const traceObj = eventTrace;
                     this._log.info(`[trace=${String(traceObj.trace_id ?? '')}] event_recv event=${sdkEvent}`);
@@ -949,16 +1347,16 @@ export class RPCTransport {
             }
             // 发布为 _raw.{event}，由 AUNClient 处理后再发布用户可见的事件
             if (sdkEvent.startsWith('app.')) {
-                this._dispatcher.publish(sdkEvent, params);
+                this._dispatcher.enqueue(sdkEvent, params);
                 return;
             }
-            this._dispatcher.publish(`_raw.${sdkEvent}`, params);
+            this._dispatcher.enqueue(`_raw.${sdkEvent}`, params);
             return;
         }
         // 其他通知
-        void this._notifyMetaObserver(message);
+        this._notifyMetaObserver(message);
         this._log.debug(`notification recv: method=${method || '<no-method>'}`);
-        this._dispatcher.publish('notification', message);
+        this._dispatcher.enqueue('notification', message);
     }
     _decodeMessage(raw) {
         if (isJsonObject(raw)) {