@qiqb/message-domain 0.0.0-stage → 0.1.4

package/build/runtime/MessageReminders.js

@@ -0,0 +1,364 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { theme } from 'antd';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { MessageReminderPresentation } from '../components/DefaultMessageReminderRenderer.js';
+import { createReminderPresentationActions } from './reminderPresentation.js';
+import { getMessageReminders, markInboxMessageRead, } from '../services/MessageController.js';
+import { getMessageDomainRuntime, openMessageInbox } from './index.js';
+import { startMessageRealtimeRefresh } from './messageRealtime.js';
+import { scanMessageReminderPages } from './reminderQuery.js';
+import { useMessageReminderTarget } from './MessageReminderLayout.js';
+import { dispatchMessageReceiptRead, subscribeMessageReceiptRead, subscribeMessageReminderPreview, } from './reminderEvents.js';
+import { acquireMessageReminderOwnership, } from './reminderOwnership.js';
+import { ReminderQueue, isReminderPreview, reminderReceiptId, } from './reminderQueue.js';
+const storageKey = (accountId, namespace) => `${namespace}:reminders:${accountId}`;
+function restoreRemembered(accountId, namespace) {
+    if (!accountId)
+        return [];
+    try {
+        const value = JSON.parse(sessionStorage.getItem(storageKey(accountId, namespace)) || '[]');
+        return Array.isArray(value)
+            ? value
+                .filter((item) => typeof item === 'string')
+                .slice(-5000)
+            : [];
+    }
+    catch {
+        // 浏览器禁止存储或旧值损坏时使用内存去重，不影响正式消息服务。
+        return [];
+    }
+}
+/**
+ * 请求、账号和导航由宿主提供；当前文档通过跨 bundle owner 选举避免重复正式提醒。
+ * namespace 内的预览单独保存，非 owner 也可预览，且预览不会进入正式队列或调用阅读接口。
+ */
+export default function MessageReminders({ accountId, onOpen, priority = 0, renderer, }) {
+    const { token } = theme.useToken();
+    const { storageNamespace: namespace, apiPrefix, realtime, } = getMessageDomainRuntime();
+    const sourceKey = JSON.stringify([apiPrefix, accountId]);
+    const previewKey = JSON.stringify([sourceKey, namespace]);
+    const currentSourceKey = useRef(sourceKey);
+    currentSourceKey.current = sourceKey;
+    const currentPreviewKey = useRef(previewKey);
+    currentPreviewKey.current = previewKey;
+    const leaseSourceKey = useRef();
+    const previewSourceKey = useRef();
+    const carouselTarget = useMessageReminderTarget();
+    const [previewTarget, setPreviewTarget] = useState();
+    const [previewRecord, setPreviewRecord] = useState();
+    const currentPreviewRecord = useRef();
+    const mounted = useRef(true);
+    const [owner, setOwner] = useState(false);
+    const leaseRef = useRef();
+    const readHandler = useRef(() => undefined);
+    const queue = useRef(new ReminderQueue());
+    const generation = useRef(0);
+    const retry = useRef(() => undefined);
+    const confirmations = useRef(new Map());
+    const [records, setRecords] = useState([]);
+    const [confirmingIds, setConfirmingIds] = useState([]);
+    const [confirmError, setConfirmError] = useState();
+    const [connectionFailed, setConnectionFailed] = useState(false);
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            // 项目展示可能保留离场动画回调；卸载时让预览与状态回调一并失效。
+            mounted.current = false;
+            currentPreviewRecord.current = undefined;
+        };
+    }, []);
+    useEffect(() => {
+        const target = document.createElement('div');
+        target.className = 'qiqb-message-reminder-preview-slot';
+        target.style.zIndex = String(token.zIndexPopupBase + 20);
+        document.body.appendChild(target);
+        setPreviewTarget(target);
+        return () => target.remove();
+    }, [token.zIndexPopupBase]);
+    const persistRemembered = useCallback(() => {
+        const lease = leaseRef.current;
+        if (!accountId || leaseSourceKey.current !== sourceKey || !lease?.isOwner())
+            return;
+        const ids = queue.current.remembered();
+        // owner 交接只传递已展示/明确关闭的收件标识，不共享正文或账号凭证。
+        lease.remember(ids);
+        try {
+            sessionStorage.setItem(storageKey(accountId, namespace), JSON.stringify(ids));
+        }
+        catch {
+            // 存储失败仍保留当前文档内存去重，阅读状态以服务端为准。
+        }
+    }, [accountId, namespace, sourceKey]);
+    const refreshRecords = useCallback(() => setRecords(queue.current.messages()), []);
+    readHandler.current = (id) => {
+        queue.current.dismiss(id);
+        persistRemembered();
+        refreshRecords();
+    };
+    useEffect(() => {
+        let active = true;
+        if (!accountId) {
+            leaseSourceKey.current = undefined;
+            setOwner(false);
+            return;
+        }
+        const lease = acquireMessageReminderOwnership({
+            apiPrefix,
+            accountId,
+            priority,
+            onOwnerChange: (value) => {
+                if (active)
+                    setOwner(value);
+            },
+            onRead: (id, readAt) => {
+                if (active)
+                    readHandler.current(id, readAt);
+            },
+            onRetry: () => {
+                // 铃铛可与 owner 位于不同 bundle；只允许当前账户的正式轮询被唤醒。
+                if (active && currentSourceKey.current === sourceKey)
+                    retry.current();
+            },
+        });
+        leaseRef.current = lease;
+        leaseSourceKey.current = sourceKey;
+        return () => {
+            active = false;
+            if (leaseRef.current === lease) {
+                leaseRef.current = undefined;
+                leaseSourceKey.current = undefined;
+            }
+            lease.release();
+        };
+    }, [accountId, apiPrefix, priority, sourceKey]);
+    useEffect(() => {
+        setPreviewRecord(undefined);
+    }, [accountId, namespace]);
+    useEffect(() => {
+        let cancelled = false;
+        let scanPage = 2;
+        ++generation.current;
+        const lease = leaseRef.current;
+        queue.current = new ReminderQueue([
+            ...restoreRemembered(accountId, namespace),
+            ...(lease?.remembered() || []),
+        ]);
+        confirmations.current.clear();
+        setRecords([]);
+        setConfirmingIds([]);
+        setConfirmError(undefined);
+        setConnectionFailed(false);
+        if (!owner || !accountId || !lease?.isOwner()) {
+            retry.current = () => undefined;
+            return () => {
+                cancelled = true;
+                ++generation.current;
+            };
+        }
+        const currentOwner = () => !cancelled &&
+            currentSourceKey.current === sourceKey &&
+            lease.isOwner() &&
+            leaseRef.current === lease;
+        const poll = async (complete) => {
+            if (!currentOwner())
+                return;
+            try {
+                // 接入实时后首次/重连/变化与低频对账扫描全部分页，不能依赖高频轮转补齐历史记录。
+                const scanned = await scanMessageReminderPages({
+                    complete,
+                    scanPage,
+                    isCurrent: currentOwner,
+                    loadPage: async (current) => (await getMessageReminders({ current, pageSize: 100 })).data,
+                    accept: (items) => {
+                        queue.current.ingest(items);
+                        refreshRecords();
+                    },
+                });
+                if (!scanned || !currentOwner())
+                    return;
+                scanPage = scanned.scanPage;
+                if (complete)
+                    queue.current.retainUnread(scanned.unreadIds);
+                setConnectionFailed(false);
+                lease.reportConnectionFailed(false);
+            }
+            catch {
+                if (currentOwner()) {
+                    setConnectionFailed(true);
+                    lease.reportConnectionFailed(true);
+                }
+            }
+            finally {
+                if (currentOwner())
+                    refreshRecords();
+            }
+        };
+        const loop = startMessageRealtimeRefresh({
+            realtime,
+            refresh: poll,
+            onChanged: (change) => {
+                if (!currentOwner())
+                    return;
+                // 服务器首次已读事件才移除正式提醒，收到普通在线数据或传输 ACK 不等于阅读。
+                if (change?.receiptId && change.readAt)
+                    lease.reportRead(change.receiptId, change.readAt);
+            },
+        });
+        retry.current = loop.wake;
+        return () => {
+            cancelled = true;
+            ++generation.current;
+            loop.release();
+            retry.current = () => undefined;
+        };
+    }, [
+        accountId,
+        namespace,
+        apiPrefix,
+        priority,
+        owner,
+        sourceKey,
+        refreshRecords,
+        realtime,
+    ]);
+    useEffect(() => {
+        const unsubscribePreview = subscribeMessageReminderPreview((record) => {
+            if (!isReminderPreview(record))
+                return;
+            previewSourceKey.current = currentPreviewKey.current;
+            setPreviewRecord(record);
+            setConfirmError(undefined);
+        });
+        const unsubscribeRead = subscribeMessageReceiptRead(({ id, readAt }) => {
+            // 同 apiPrefix/账号的 owner 接收其他 namespace 已确认的阅读事实，避免保留旧全屏提醒。
+            if (leaseRef.current)
+                leaseRef.current.reportRead(id, readAt);
+            else
+                readHandler.current(id, readAt);
+        });
+        return () => {
+            unsubscribePreview();
+            unsubscribeRead();
+        };
+    }, [namespace]);
+    const dismiss = useCallback((id) => {
+        if (id.startsWith('preview:')) {
+            setPreviewRecord((current) => current && reminderReceiptId(current) === id ? undefined : current);
+            return;
+        }
+        // 关闭正式提醒仅结束当前展示，收件箱未读状态不随关闭改变。
+        queue.current.dismiss(id);
+        persistRemembered();
+        refreshRecords();
+    }, [persistRemembered, refreshRecords]);
+    const displayed = useCallback((record) => {
+        if (leaseRef.current?.isOwner() && queue.current.presented(record))
+            persistRemembered();
+    }, [persistRemembered]);
+    const confirm = useCallback((record) => {
+        const id = reminderReceiptId(record);
+        if (isReminderPreview(record)) {
+            dismiss(id);
+            return Promise.resolve();
+        }
+        const lease = leaseRef.current;
+        if (!lease?.isOwner())
+            return Promise.reject(new Error('消息提醒已由其他入口接管'));
+        const pending = confirmations.current.get(id);
+        if (pending)
+            return pending;
+        const version = generation.current;
+        setConfirmError(undefined);
+        setConfirmingIds((current) => [...current, id]);
+        const operation = (async () => {
+            try {
+                // 仅明确点击确认/查看才标已读，浮动、轮播、全屏出现本身均不更改服务端状态。
+                await markInboxMessageRead(id);
+                const readAt = new Date().toISOString();
+                lease.reportRead(id, readAt);
+                if (version !== generation.current ||
+                    currentSourceKey.current !== sourceKey ||
+                    !lease.isOwner())
+                    return;
+                dismiss(id);
+                dispatchMessageReceiptRead(id, readAt);
+            }
+            catch (error) {
+                if (version === generation.current &&
+                    currentSourceKey.current === sourceKey &&
+                    lease.isOwner())
+                    setConfirmError(error instanceof Error ? error.message : '确认失败，请重试');
+                throw error;
+            }
+            finally {
+                if (version === generation.current) {
+                    confirmations.current.delete(id);
+                    setConfirmingIds((current) => current.filter((value) => value !== id));
+                }
+            }
+        })();
+        confirmations.current.set(id, operation);
+        return operation;
+    }, [dismiss, sourceKey]);
+    const open = (record) => {
+        if (isReminderPreview(record)) {
+            dismiss(reminderReceiptId(record));
+            return;
+        }
+        const version = generation.current;
+        void confirm(record)
+            .then(() => {
+            if (version === generation.current &&
+                currentSourceKey.current === sourceKey &&
+                leaseRef.current?.isOwner())
+                (onOpen || openMessageInbox)(record);
+        })
+            .catch(() => undefined);
+    };
+    // 只有实际 owner 的正式队列进入展示；本 namespace 预览独立于 owner 选举。
+    // 在退出/换账号的首个渲染便隐藏旧内容，不等待被动 effect 清理，避免新账号短暂看到旧消息。
+    const ownsFormal = owner &&
+        leaseSourceKey.current === sourceKey &&
+        !!leaseRef.current?.isOwner();
+    const formalRecords = ownsFormal ? records : [];
+    const activePreview = previewSourceKey.current === previewKey ? previewRecord : undefined;
+    currentPreviewRecord.current = activePreview;
+    const previewingCarousel = activePreview?.reminderMode === 'CAROUSEL';
+    const displayRecords = [
+        ...(activePreview ? [activePreview] : []),
+        ...formalRecords.filter((record) => !previewingCarousel || record.reminderMode !== 'CAROUSEL'),
+    ];
+    // 展示层得到记录的浅拷贝；业务组件修改临时外观字段不会改动平台队列中的原始快照。
+    const displayMessages = displayRecords.map((record) => ({ ...record }));
+    const snapshot = {
+        sourceKey,
+        previewKey,
+        queue: queue.current,
+        lease: leaseRef.current,
+        preview: activePreview,
+    };
+    const presentationActions = createReminderPresentationActions(displayMessages, snapshot, () => ({
+        sourceKey: currentSourceKey.current,
+        previewKey: currentPreviewKey.current,
+        queue: queue.current,
+        lease: leaseRef.current,
+        preview: currentPreviewRecord.current,
+    }), {
+        onDismiss: dismiss,
+        onOpen: open,
+        onConfirm: confirm,
+        onDisplayed: displayed,
+    });
+    const samePresentation = () => mounted.current &&
+        currentSourceKey.current === sourceKey &&
+        currentPreviewKey.current === previewKey &&
+        queue.current === snapshot.queue &&
+        leaseRef.current === snapshot.lease;
+    return (_jsx(MessageReminderPresentation, { renderer: renderer, accountId: accountId, messages: displayMessages, carouselTarget: previewingCarousel ? previewTarget : carouselTarget, ...presentationActions, confirmingIds: ownsFormal ? confirmingIds : [], confirmError: ownsFormal ? confirmError : undefined, connectionFailed: !!accountId && ownsFormal && connectionFailed, onRetry: () => {
+            if (samePresentation() && snapshot.lease?.isOwner())
+                retry.current();
+        }, onClearError: () => {
+            if (samePresentation())
+                setConfirmError(undefined);
+        } }, previewKey));
+}

package/build/runtime/index.d.ts

@@ -0,0 +1,79 @@
+import type { InboxMessage } from '../services/MessageController.js';
+import type { MessageReminderRenderer } from './reminderPresentation.js';
+export interface MessageRequestOptions {
+    method?: string;
+    params?: unknown;
+    data?: unknown;
+    headers?: HeadersInit;
+    skipErrorHandler?: boolean;
+    [key: string]: unknown;
+}
+export type MessageRequest = <T = unknown>(url: string, options?: MessageRequestOptions) => Promise<T>;
+export interface MessageDomainAccess {
+    verifyElementPermission?: (code?: string, projectCode?: string) => boolean;
+}
+export type MessageRealtimeState = 'idle' | 'connecting' | 'connected' | 'disconnected' | 'disabled' | 'released';
+/** 在线事件只提示收件事实变化，正文继续通过当前账号的 HTTP 接口查询。 */
+export interface MessageInboxChange {
+    receiptId?: string;
+    readAt?: string;
+}
+export interface MessageRealtimeLease {
+    getState(): MessageRealtimeState;
+    onStateChange(listener: (state: MessageRealtimeState) => void, emitImmediately?: boolean): () => void;
+    onChanged(listener: (change: MessageInboxChange) => void): () => void;
+    release(): void;
+}
+export interface MessageRealtimeAdapter {
+    /** 宿主提供同账户共享的连接租约；消息包不直接依赖 Socket.IO 客户端。 */
+    acquire(): MessageRealtimeLease;
+}
+/**
+ * 消息领域与宿主之间的稳定边界。宿主在页面挂载前配置一次，控制器和页面随后读取同一实现。
+ * request 继续使用宿主 token/超时处理；包不引用 Umi、平台页面包或任一业务 shared 包。
+ */
+export interface MessageDomainRuntimeAdapter {
+    realtime?: MessageRealtimeAdapter;
+    request?: MessageRequest;
+    navigate?: (path: string) => void;
+    useLocation?: () => {
+        search: string;
+    };
+    useAccess?: () => MessageDomainAccess;
+    onOpen?: (record: InboxMessage) => void;
+    /** 未提供时使用平台默认外观；只替换展示，消息生命周期和数据隔离由平台继续维护。 */
+    reminderRenderer?: MessageReminderRenderer;
+    /** 字段名称属于发布方业务语义；宿主可提供工厂/订单等名称，平台默认只显示通用标签。 */
+    fieldLabel?: (field: string) => string | undefined;
+    apiPrefix?: string;
+    projectCode?: string;
+    /** 宿主创建消息主题的业务来源，与发布接口的 sourceSystem 一致；不由权限项目号推断。 */
+    sourceSystem?: string;
+    inboxPath?: string;
+    receiptQueryParam?: string;
+    /** BIP 传入 prokeeper-bip 可沿用原来的 sessionStorage 收件标识去重记录。 */
+    storageNamespace?: string;
+    /** 默认跟随 storageNamespace，隔离同一浏览器文档中不同业务域的预览事件。 */
+    eventNamespace?: string;
+}
+export type MessageDomainRuntime = MessageDomainRuntimeAdapter & {
+    apiPrefix: string;
+    projectCode: string;
+    inboxPath: string;
+    receiptQueryParam: string;
+    storageNamespace: string;
+    eventNamespace: string;
+};
+export declare function configureMessageDomainRuntime(adapter: MessageDomainRuntimeAdapter): void;
+export declare const getMessageDomainRuntime: () => Readonly<MessageDomainRuntime>;
+export declare const request: MessageRequest;
+/** 缺少授权适配器时默认拒绝写操作；显式项目编码不跟随宿主当前菜单而漂移。 */
+export declare function useAccess(): {
+    verifyElementPermission: (code?: string, projectCode?: string) => boolean;
+};
+export declare const useLocation: () => {
+    search: string;
+};
+export declare function navigate(path: string): void;
+export declare function openMessageInbox(record: InboxMessage): void;
+export declare function getMessageFieldLabel(field: string): string;

package/build/runtime/index.js

@@ -0,0 +1,105 @@
+import { useSyncExternalStore } from 'react';
+import { MESSAGE_BASE_PATH } from '../routes.js';
+let runtime = {
+    apiPrefix: '/api/qiqb_platform/message',
+    projectCode: 'qiqb_platform',
+    inboxPath: `${MESSAGE_BASE_PATH}/inbox`,
+    receiptQueryParam: 'receiptId',
+    storageNamespace: 'qiqb-platform',
+    eventNamespace: 'qiqb-platform',
+};
+export function configureMessageDomainRuntime(adapter) {
+    const next = { ...runtime, ...adapter };
+    // 来源编码保留大小写，后端会严格核对；显式清空时不沿用其它宿主的来源。
+    next.sourceSystem = next.sourceSystem?.trim() || undefined;
+    next.apiPrefix = (adapter.apiPrefix ?? runtime.apiPrefix).replace(/\/+$/, '');
+    next.projectCode = adapter.projectCode?.trim() || runtime.projectCode;
+    next.storageNamespace =
+        adapter.storageNamespace?.trim() || runtime.storageNamespace;
+    next.eventNamespace =
+        adapter.eventNamespace?.trim() ||
+            (adapter.storageNamespace !== undefined
+                ? next.storageNamespace
+                : runtime.eventNamespace);
+    next.inboxPath = adapter.inboxPath || runtime.inboxPath;
+    next.receiptQueryParam =
+        adapter.receiptQueryParam?.trim() || runtime.receiptQueryParam;
+    runtime = next;
+}
+export const getMessageDomainRuntime = () => runtime;
+/** fetch 仅用于无框架预览；登录鉴权、token 续期和错误策略应由正式宿主的 request 注入。 */
+const fetchRequest = async (url, options = {}) => {
+    const { method = 'GET', params, data, headers, skipErrorHandler: _skip, ...rest } = options;
+    const search = new URLSearchParams();
+    if (params && typeof params === 'object') {
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null)
+                continue;
+            for (const item of Array.isArray(value) ? value : [value])
+                search.append(key, String(item));
+        }
+    }
+    const query = search.toString();
+    const target = query ? `${url}${url.includes('?') ? '&' : '?'}${query}` : url;
+    const requestHeaders = new Headers(headers);
+    if (data !== undefined && !requestHeaders.has('Content-Type'))
+        requestHeaders.set('Content-Type', 'application/json');
+    const response = await fetch(target, {
+        credentials: 'same-origin',
+        ...rest,
+        method,
+        headers: requestHeaders,
+        ...(data !== undefined && method.toUpperCase() !== 'GET'
+            ? { body: JSON.stringify(data) }
+            : {}),
+    });
+    if (!response.ok)
+        throw new Error((await response.text()) || `消息服务请求失败（${response.status}）`);
+    return (response.status === 204 ? undefined : await response.json());
+};
+export const request = (url, options) => (runtime.request || fetchRequest)(url, options);
+/** 缺少授权适配器时默认拒绝写操作；显式项目编码不跟随宿主当前菜单而漂移。 */
+export function useAccess() {
+    const access = runtime.useAccess?.();
+    return {
+        verifyElementPermission: (code, projectCode = runtime.projectCode) => !!code && !!access?.verifyElementPermission?.(code, projectCode),
+    };
+}
+const subscribeLocation = (listener) => {
+    if (typeof window === 'undefined')
+        return () => undefined;
+    window.addEventListener('popstate', listener);
+    return () => window.removeEventListener('popstate', listener);
+};
+const browserSearch = () => typeof window === 'undefined' ? '' : window.location.search;
+function useBrowserLocation() {
+    const search = useSyncExternalStore(subscribeLocation, browserSearch, () => '');
+    return { search };
+}
+export const useLocation = () => (runtime.useLocation || useBrowserLocation)();
+export function navigate(path) {
+    // 跳转只接受站内根路径；宿主可注入带微前端 basename 的路由适配器。
+    if (!path.startsWith('/') ||
+        path.startsWith('//') ||
+        /[\\\u0000-\u001f\u007f]/.test(path))
+        throw new Error('消息跳转地址必须为站内路径');
+    if (runtime.navigate)
+        runtime.navigate(path);
+    else if (typeof window !== 'undefined')
+        window.location.assign(path);
+}
+export function openMessageInbox(record) {
+    if (runtime.onOpen)
+        return runtime.onOpen(record);
+    const [path, fragment] = runtime.inboxPath.split('#', 2);
+    const target = `${path}${path.includes('?') ? '&' : '?'}${encodeURIComponent(runtime.receiptQueryParam)}=${encodeURIComponent(record.receiptId || record.id)}`;
+    navigate(fragment === undefined ? target : `${target}#${fragment}`);
+}
+export function getMessageFieldLabel(field) {
+    const common = {
+        severity: '级别',
+        businessType: '业务类型',
+        regionId: '地区',
+    };
+    return runtime.fieldLabel?.(field) || common[field] || field;
+}

package/build/runtime/message-reminder-layout.less

@@ -0,0 +1,40 @@
+// 消息栏属于宿主内容流，不使用视口左右坐标猜测侧栏宽度。
+.qiqb-message-reminder-layout {
+  width: 100%;
+  min-width: 0;
+  min-height: 100%;
+}
+
+.qiqb-message-reminder-slot {
+  // 横跨二级菜单与页面的共同内容区，贴合宿主页头下方，不额外留出页面卡片的边距。
+  position: relative;
+  width: 100%;
+  min-width: 0;
+
+  // Portal 有内容才留出位置；没有轮播消息时业务页面完全按原布局显示。
+  &:empty {
+    display: none;
+  }
+}
+
+// 编辑主题的预览在弹窗上方显示，关闭预览后立即释放节点占位。
+// 真实消息始终进入内容区槽位，只有配置预览使用这处窄幅浮层。
+.qiqb-message-reminder-preview-slot {
+  position: fixed;
+  top: 20px;
+  left: 50%;
+  width: 860px;
+  max-width: calc(100vw - 32px);
+  transform: translateX(-50%);
+
+  &:empty {
+    display: none;
+  }
+}
+
+@media (max-width: 767px) {
+  .qiqb-message-reminder-preview-slot {
+    top: 12px;
+    width: calc(100vw - 24px);
+  }
+}

package/build/runtime/messageRealtime.d.ts

@@ -0,0 +1,15 @@
+import type { MessageInboxChange, MessageRealtimeAdapter } from './index.js';
+interface MessageRefreshOptions {
+    realtime?: MessageRealtimeAdapter;
+    refresh: (complete: boolean) => Promise<void>;
+    onChanged?: (change: MessageInboxChange) => void;
+}
+/**
+ * 在线事件只唤醒 HTTP 投影；连接正常时低频对账，未接入或断线时保留原五秒补偿。
+ * 同一查询进行中收到事件会合并为下一次刷新，不能丢掉在途请求之后的新收件/已读变化。
+ */
+export declare function startMessageRealtimeRefresh(options: MessageRefreshOptions): {
+    wake: () => void;
+    release(): void;
+};
+export {};