@qiqb/message-domain 0.0.0-stage → 0.1.3

package/build/runtime/messageRealtime.js

@@ -0,0 +1,99 @@
+/**
+ * 在线事件只唤醒 HTTP 投影；连接正常时低频对账，未接入或断线时保留原五秒补偿。
+ * 同一查询进行中收到事件会合并为下一次刷新，不能丢掉在途请求之后的新收件/已读变化。
+ */
+export function startMessageRealtimeRefresh(options) {
+    let active = true;
+    let running = false;
+    let pending = false;
+    let complete = !!options.realtime;
+    let connected = false;
+    let timer;
+    let lease;
+    let offChanged;
+    let offState;
+    const poll = async () => {
+        if (!active || document.visibilityState === 'hidden')
+            return;
+        if (running) {
+            pending = true;
+            return;
+        }
+        running = true;
+        pending = false;
+        const full = complete || connected;
+        complete = false;
+        try {
+            await options.refresh(full);
+        }
+        catch {
+            // 界面查询负责展示自己的错误；调度仍继续补偿，不能留下未处理的 Promise 拒绝。
+        }
+        finally {
+            running = false;
+            if (!active)
+                return;
+            if (pending) {
+                void poll();
+                return;
+            }
+            timer = setTimeout(() => void poll(), connected ? 60000 : 5000);
+        }
+    };
+    const wake = () => {
+        if (!active)
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = undefined;
+        void poll();
+    };
+    if (options.realtime) {
+        try {
+            lease = options.realtime.acquire();
+            connected = lease.getState() === 'connected';
+            offChanged = lease.onChanged((change) => {
+                if (!active)
+                    return;
+                options.onChanged?.(change);
+                // 变化事件没有正文，完整补查还可移除其它设备已经读过的队列记录。
+                complete = true;
+                wake();
+            });
+            offState = lease.onStateChange((state) => {
+                if (!active)
+                    return;
+                const nextConnected = state === 'connected';
+                if (nextConnected === connected)
+                    return;
+                connected = nextConnected;
+                complete = true;
+                wake();
+            }, false);
+        }
+        catch {
+            // 宿主扩展初始化失败时继续 HTTP 补偿，不让可选实时能力阻止消息入口挂载。
+            offChanged?.();
+            offState?.();
+            lease?.release();
+            lease = undefined;
+            connected = false;
+        }
+    }
+    document.addEventListener('visibilitychange', wake);
+    wake();
+    return {
+        wake,
+        release() {
+            if (!active)
+                return;
+            active = false;
+            if (timer)
+                clearTimeout(timer);
+            document.removeEventListener('visibilitychange', wake);
+            offChanged?.();
+            offState?.();
+            lease?.release();
+        },
+    };
+}

package/build/runtime/reminderEvents.d.ts

@@ -0,0 +1,18 @@
+import type { InboxMessage } from '../services/MessageController.js';
+/** 默认平台事件名称；实际派发/订阅通过运行时 namespace，允许 BIP 保持旧事件上下文。 */
+export declare const MESSAGE_REMINDER_PREVIEW_EVENT: "qiqb-platform:message-reminder-preview";
+export declare const MESSAGE_RECEIPT_READ_EVENT: "qiqb-platform:message-receipt-read";
+export type MessageReminderPreviewEvent = CustomEvent<InboxMessage>;
+export interface MessageReceiptReadDetail {
+    id: string;
+    readAt: string;
+}
+export declare function getMessageReminderEventNames(): {
+    preview: string;
+    read: string;
+};
+/** 预览仅使用浏览器本地事件，不保存主题、不发布消息、不更改阅读状态。 */
+export declare function dispatchMessageReminderPreview(record: InboxMessage): void;
+export declare function dispatchMessageReceiptRead(id: string, readAt?: string): void;
+export declare function subscribeMessageReminderPreview(listener: (record: InboxMessage) => void): () => void;
+export declare function subscribeMessageReceiptRead(listener: (detail: MessageReceiptReadDetail) => void): () => void;

package/build/runtime/reminderEvents.js

@@ -0,0 +1,53 @@
+import { getMessageDomainRuntime } from './index.js';
+/** 默认平台事件名称；实际派发/订阅通过运行时 namespace，允许 BIP 保持旧事件上下文。 */
+export const MESSAGE_REMINDER_PREVIEW_EVENT = 'qiqb-platform:message-reminder-preview';
+export const MESSAGE_RECEIPT_READ_EVENT = 'qiqb-platform:message-receipt-read';
+export function getMessageReminderEventNames() {
+    const namespace = getMessageDomainRuntime().eventNamespace;
+    return {
+        preview: `${namespace}:message-reminder-preview`,
+        read: `${namespace}:message-receipt-read`,
+    };
+}
+/** 预览仅使用浏览器本地事件，不保存主题、不发布消息、不更改阅读状态。 */
+export function dispatchMessageReminderPreview(record) {
+    if (typeof window === 'undefined')
+        return;
+    window.dispatchEvent(new CustomEvent(getMessageReminderEventNames().preview, {
+        detail: record,
+    }));
+}
+export function dispatchMessageReceiptRead(id, readAt = new Date().toISOString()) {
+    if (typeof window === 'undefined')
+        return;
+    window.dispatchEvent(new CustomEvent(getMessageReminderEventNames().read, { detail: { id, readAt } }));
+}
+export function subscribeMessageReminderPreview(listener) {
+    if (typeof window === 'undefined')
+        return () => undefined;
+    const name = getMessageReminderEventNames().preview;
+    const receive = (event) => {
+        const record = event.detail;
+        if (record &&
+            typeof (record.receiptId || record.id) === 'string' &&
+            typeof record.title === 'string' &&
+            typeof record.content === 'string')
+            listener(record);
+    };
+    window.addEventListener(name, receive);
+    return () => window.removeEventListener(name, receive);
+}
+export function subscribeMessageReceiptRead(listener) {
+    if (typeof window === 'undefined')
+        return () => undefined;
+    const name = getMessageReminderEventNames().read;
+    const receive = (event) => {
+        const detail = event.detail;
+        if (detail &&
+            typeof detail.id === 'string' &&
+            typeof detail.readAt === 'string')
+            listener(detail);
+    };
+    window.addEventListener(name, receive);
+    return () => window.removeEventListener(name, receive);
+}

package/build/runtime/reminderOwnership.d.ts

@@ -0,0 +1,35 @@
+export interface MessageReminderLease {
+    isOwner(): boolean;
+    remembered(): string[];
+    remember(ids: string[]): void;
+    reportRead(id: string, readAt: string): void;
+    reportConnectionFailed(failed: boolean): void;
+    release(): void;
+}
+export interface MessageReminderOwnershipOptions {
+    apiPrefix: string;
+    accountId: string;
+    priority?: number;
+    onOwnerChange: (owner: boolean) => void;
+    onRead?: (id: string, readAt: string) => void;
+    /** 导航重试只唤醒当前 owner，其他入口不启动新的正式提醒轮询。 */
+    onRetry?: () => void;
+}
+/**
+ * 铃铛只订阅同源、同账户的连接状态，不加入 owner 选举，也不保留正式消息队列。
+ * 使用现有跨 bundle 注册表而非 namespace 事件，宿主与微应用都能感知实际 owner。
+ */
+export declare function subscribeMessageReminderConnection(source: {
+    apiPrefix: string;
+    accountId: string;
+}, listener: (failed: boolean) => void): () => void;
+/** 重试始终解析当前 owner；旧入口释放后不保留可调用的轮询回调。 */
+export declare function retryMessageReminderConnection(source: {
+    apiPrefix: string;
+    accountId: string;
+}): void;
+/**
+ * 一份后端消息源、同一账号在同一 document 中只允许一个正式提醒入口。
+ * namespace 不参与选举：平台宿主与业务微应用可保留各自预览/存储命名空间，但不会同时弹正式消息。
+ */
+export declare function acquireMessageReminderOwnership(options: MessageReminderOwnershipOptions): MessageReminderLease;

package/build/runtime/reminderOwnership.js

@@ -0,0 +1,135 @@
+// document.defaultView 是 qiankun 沙箱之外的同一文档窗口，Symbol.for 在不同 bundle 中指向同一键。
+const registrySymbol = Symbol.for('@qiqb/message-domain/reminder-owner:v1');
+function getRegistry() {
+    const view = typeof document === 'undefined' ? undefined : document.defaultView;
+    if (!view)
+        return;
+    const shared = view;
+    return (shared[registrySymbol] || (shared[registrySymbol] = { nextId: 0, entries: new Map() }));
+}
+const sourceKey = (source) => JSON.stringify([source.apiPrefix.replace(/\/+$/, ''), source.accountId]);
+function reportConnectionFailed(registry, key, entry, failed) {
+    if (!!entry.connectionFailed === failed)
+        return;
+    entry.connectionFailed = failed;
+    for (const listener of [...(registry.connectionListeners?.get(key) || [])])
+        listener(failed);
+}
+function elect(registry, key, entry) {
+    const winner = [...entry.members.values()].sort((a, b) => b.priority - a.priority || a.id - b.id)[0]?.id;
+    if (winner === entry.owner)
+        return;
+    const previous = entry.owner;
+    entry.owner = winner;
+    // 断开状态属于实际查询的 owner；交接后等待新 owner 的结果，不继承旧入口的失败。
+    reportConnectionFailed(registry, key, entry, false);
+    // 先让旧 owner 停止展示/轮询，再激活新 owner；同优先级按登记先后稳定选举。
+    if (previous !== undefined)
+        entry.members.get(previous)?.onOwnerChange(false);
+    if (winner !== undefined)
+        entry.members.get(winner)?.onOwnerChange(true);
+}
+/**
+ * 铃铛只订阅同源、同账户的连接状态，不加入 owner 选举，也不保留正式消息队列。
+ * 使用现有跨 bundle 注册表而非 namespace 事件，宿主与微应用都能感知实际 owner。
+ */
+export function subscribeMessageReminderConnection(source, listener) {
+    const registry = getRegistry();
+    if (!registry)
+        return () => undefined;
+    const key = sourceKey(source);
+    const subscriptions = (registry.connectionListeners || (registry.connectionListeners = new Map()));
+    let listeners = subscriptions.get(key);
+    if (!listeners) {
+        listeners = new Set();
+        subscriptions.set(key, listeners);
+    }
+    listeners.add(listener);
+    // 导航晚于提醒入口挂载时立即回放，避免已断开的连接要等下一轮失败才显示。
+    listener(!!registry.entries.get(key)?.connectionFailed);
+    return () => {
+        listeners.delete(listener);
+        if (!listeners.size)
+            subscriptions.delete(key);
+    };
+}
+/** 重试始终解析当前 owner；旧入口释放后不保留可调用的轮询回调。 */
+export function retryMessageReminderConnection(source) {
+    const entry = getRegistry()?.entries.get(sourceKey(source));
+    if (entry?.owner !== undefined)
+        entry.members.get(entry.owner)?.onRetry?.();
+}
+function remember(entry, ids) {
+    for (const id of ids)
+        if (id && !id.startsWith('preview:'))
+            entry.remembered.add(id);
+    if (entry.remembered.size > 5000)
+        entry.remembered = new Set([...entry.remembered].slice(-5000));
+}
+/**
+ * 一份后端消息源、同一账号在同一 document 中只允许一个正式提醒入口。
+ * namespace 不参与选举：平台宿主与业务微应用可保留各自预览/存储命名空间，但不会同时弹正式消息。
+ */
+export function acquireMessageReminderOwnership(options) {
+    const registry = getRegistry();
+    if (!registry) {
+        options.onOwnerChange(false);
+        return {
+            isOwner: () => false,
+            remembered: () => [],
+            remember: () => undefined,
+            reportRead: () => undefined,
+            reportConnectionFailed: () => undefined,
+            release: () => undefined,
+        };
+    }
+    const key = sourceKey(options);
+    let entry = registry.entries.get(key);
+    if (!entry) {
+        entry = { members: new Map(), remembered: new Set() };
+        registry.entries.set(key, entry);
+    }
+    const id = ++registry.nextId;
+    let released = false;
+    const member = {
+        ...options,
+        id,
+        priority: Number.isFinite(options.priority) ? options.priority : 0,
+    };
+    entry.members.set(id, member);
+    member.onOwnerChange(false);
+    elect(registry, key, entry);
+    const currentEntry = entry;
+    return {
+        isOwner: () => !released && currentEntry.owner === id,
+        remembered: () => [...currentEntry.remembered],
+        remember: (ids) => {
+            if (!released)
+                remember(currentEntry, ids);
+        },
+        reportRead: (receiptId, readAt) => {
+            // 即使确认请求返回时旧 owner 已卸载，服务端已读事实仍可通知接管同一账号的入口。
+            const active = registry.entries.get(key);
+            if (!active)
+                return;
+            remember(active, [receiptId]);
+            for (const receiver of [...active.members.values()])
+                receiver.onRead?.(receiptId, readAt);
+        },
+        reportConnectionFailed: (failed) => {
+            // 迟到响应和失去所有权的入口不能覆盖当前账户正在使用的连接状态。
+            if (!released && currentEntry.owner === id)
+                reportConnectionFailed(registry, key, currentEntry, failed);
+        },
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            member.onOwnerChange(false);
+            currentEntry.members.delete(id);
+            elect(registry, key, currentEntry);
+            if (!currentEntry.members.size)
+                registry.entries.delete(key);
+        },
+    };
+}

package/build/runtime/reminderPresentation.d.ts

@@ -0,0 +1,34 @@
+import type { ComponentType } from 'react';
+import type { MessageReminderDisplayProps } from '../components/MessageReminderDisplay.js';
+import type { InboxMessage } from '../services/MessageController.js';
+import type { MessageReminderLease } from './reminderOwnership.js';
+import { ReminderQueue } from './reminderQueue.js';
+/**
+ * 项目只替换展示组件，查询、账户隔离、所有者选举和已读接口仍由平台运行时负责。
+ * 三种提醒方式与消息级别来自发布快照；组件可以完整重画，也可以包装默认组件。
+ */
+export interface MessageReminderRendererProps extends MessageReminderDisplayProps {
+    accountId?: string;
+    connectionFailed: boolean;
+    onRetry: () => void;
+    onClearError: () => void;
+    /** 必须在消息实际可见时报告；传入列表、隐藏项或排队项不代表用户已经看到。 */
+    onDisplayed: (record: InboxMessage) => void;
+}
+/** 使用 React 组件而非普通 render 回调，项目组件可以正常使用自己的 Hooks。 */
+export type MessageReminderRenderer = ComponentType<MessageReminderRendererProps>;
+export type MessageReminderActions = Pick<MessageReminderRendererProps, 'onDismiss' | 'onOpen' | 'onConfirm' | 'onDisplayed'>;
+/** 内部展示快照：自定义组件可能保留动画/定时器回调，不能让旧入口操作新账户队列。 */
+export interface ReminderPresentationSnapshot {
+    sourceKey: string;
+    previewKey: string;
+    queue: ReminderQueue;
+    lease?: MessageReminderLease;
+    preview?: InboxMessage;
+}
+/**
+ * 回调在生成时捕获快照，在执行时读取当前状态。正式消息还必须属于当前 owner 的队列。
+ * 使用队列中的原始快照处理确认/展示，防止展示组件传入改过提醒方式的临时对象影响去重。
+ * 预览独立校验其当前标识，不依赖正式 owner，也不会执行真实消息的阅读接口。
+ */
+export declare function createReminderPresentationActions(messages: InboxMessage[], snapshot: ReminderPresentationSnapshot, getCurrent: () => ReminderPresentationSnapshot, handlers: MessageReminderActions): MessageReminderActions;

package/build/runtime/reminderPresentation.js

@@ -0,0 +1,57 @@
+import { reminderReceiptId } from './reminderQueue.js';
+/**
+ * 回调在生成时捕获快照，在执行时读取当前状态。正式消息还必须属于当前 owner 的队列。
+ * 使用队列中的原始快照处理确认/展示，防止展示组件传入改过提醒方式的临时对象影响去重。
+ * 预览独立校验其当前标识，不依赖正式 owner，也不会执行真实消息的阅读接口。
+ */
+export function createReminderPresentationActions(messages, snapshot, getCurrent, handlers) {
+    const ids = new Set(messages.map(reminderReceiptId));
+    const currentRecord = (id) => {
+        if (!ids.has(id))
+            return;
+        const current = getCurrent();
+        if (current.sourceKey !== snapshot.sourceKey ||
+            current.previewKey !== snapshot.previewKey)
+            return;
+        if (id.startsWith('preview:')) {
+            return snapshot.preview &&
+                current.preview &&
+                reminderReceiptId(snapshot.preview) === id &&
+                reminderReceiptId(current.preview) === id
+                ? current.preview
+                : undefined;
+        }
+        if (current.queue !== snapshot.queue ||
+            current.lease !== snapshot.lease ||
+            !snapshot.lease?.isOwner())
+            return;
+        return current.queue
+            .messages()
+            .find((record) => reminderReceiptId(record) === id);
+    };
+    return {
+        onDismiss: (id) => {
+            const record = currentRecord(id);
+            // 自定义组件同样不能通过关闭回调绕过全屏确认；预览仍可以直接结束。
+            if (record &&
+                (id.startsWith('preview:') || record.reminderMode !== 'FULLSCREEN'))
+                handlers.onDismiss(id);
+        },
+        onOpen: (record) => {
+            const current = currentRecord(reminderReceiptId(record));
+            if (current)
+                handlers.onOpen(current);
+        },
+        onConfirm: (record) => {
+            const current = currentRecord(reminderReceiptId(record));
+            return current
+                ? handlers.onConfirm(current)
+                : Promise.reject(new Error('消息提醒已更新，请使用当前消息操作'));
+        },
+        onDisplayed: (record) => {
+            const current = currentRecord(reminderReceiptId(record));
+            if (current)
+                handlers.onDisplayed(current);
+        },
+    };
+}

package/build/runtime/reminderQuery.d.ts

@@ -0,0 +1,18 @@
+import type { InboxMessage } from '../services/MessageController.js';
+interface ReminderPage {
+    total?: number;
+    records?: InboxMessage[];
+}
+interface ReminderScanOptions {
+    complete: boolean;
+    scanPage: number;
+    loadPage: (current: number) => Promise<ReminderPage | undefined>;
+    accept: (records: InboxMessage[]) => void;
+    isCurrent: () => boolean;
+}
+/** 无实时连接时沿用两页历史轮转；完整同步成功后才返回全量收件标识用于已读对账。 */
+export declare function scanMessageReminderPages(options: ReminderScanOptions): Promise<{
+    unreadIds: string[];
+    scanPage: number;
+} | undefined>;
+export {};

package/build/runtime/reminderQuery.js

@@ -0,0 +1,33 @@
+/** 无实时连接时沿用两页历史轮转；完整同步成功后才返回全量收件标识用于已读对账。 */
+export async function scanMessageReminderPages(options) {
+    const first = await options.loadPage(1);
+    if (!options.isCurrent())
+        return;
+    if (!first)
+        throw new Error('消息提醒分页未返回数据');
+    const unreadIds = [];
+    const accept = (page) => {
+        const records = page?.records || [];
+        unreadIds.push(...records.map((record) => record.receiptId || record.id));
+        options.accept(records);
+    };
+    accept(first);
+    const lastPage = Math.ceil((first?.total || 0) / 100);
+    let scanPage = options.scanPage;
+    const count = options.complete
+        ? Math.max(0, lastPage - 1)
+        : Math.min(2, Math.max(0, lastPage - 1));
+    for (let extra = 0; extra < count; extra++) {
+        if (!options.isCurrent())
+            return;
+        if (scanPage > lastPage)
+            scanPage = 2;
+        const page = await options.loadPage(options.complete ? extra + 2 : scanPage++);
+        if (!options.isCurrent())
+            return;
+        if (!page)
+            throw new Error('消息提醒分页未返回数据');
+        accept(page);
+    }
+    return { unreadIds, scanPage };
+}

package/build/runtime/reminderQueue.d.ts

@@ -0,0 +1,25 @@
+import type { InboxMessage } from '../services/MessageController.js';
+export declare const reminderReceiptId: (record: InboxMessage) => string;
+export declare const isReminderPreview: (record: InboxMessage) => boolean;
+/** 按本地浏览器时区解释后端的无时区时间，和收件箱的时间展示保持一致。 */
+export declare function reminderHasExpired(record: InboxMessage, now?: number): boolean;
+/** 级别只影响队列优先级，不改变客户配置的展示方式。 */
+export declare function compareReminders(left: InboxMessage, right: InboxMessage): number;
+/**
+ * 独立于 React 的当前账号提醒队列。
+ * 轮询重复返回同一收件记录时不会重复创建提醒，尚未真正显示的排队消息不能提前记为已提醒。
+ */
+export declare class ReminderQueue {
+    private capacity;
+    private records;
+    private seen;
+    constructor(remembered?: string[], capacity?: number);
+    ingest(messages: InboxMessage[], now?: number): void;
+    messages(now?: number): InboxMessage[];
+    /** 完整未读投影查询成功后移除缺失记录；分页中途失败时调用方不能进行这一步。 */
+    retainUnread(ids: Iterable<string>): void;
+    presented(record: InboxMessage): boolean;
+    dismiss(id: string): void;
+    preview(record: InboxMessage): void;
+    remembered(): string[];
+}

package/build/runtime/reminderQueue.js

@@ -0,0 +1,88 @@
+export const reminderReceiptId = (record) => record.receiptId || record.id;
+export const isReminderPreview = (record) => reminderReceiptId(record).startsWith('preview:');
+/** 按本地浏览器时区解释后端的无时区时间，和收件箱的时间展示保持一致。 */
+export function reminderHasExpired(record, now = Date.now()) {
+    return (!!record.expiresAt &&
+        new Date(record.expiresAt.replace(' ', 'T')).getTime() <= now);
+}
+const levelOrder = { NORMAL: 0, IMPORTANT: 1, SEVERE: 2 };
+const timeOf = (record) => {
+    const value = new Date((record.createTime || '').replace(' ', 'T')).getTime();
+    return Number.isNaN(value) ? 0 : value;
+};
+/** 级别只影响队列优先级，不改变客户配置的展示方式。 */
+export function compareReminders(left, right) {
+    return (Number(isReminderPreview(right)) - Number(isReminderPreview(left)) ||
+        (levelOrder[right.messageLevel || 'NORMAL'] || 0) -
+            (levelOrder[left.messageLevel || 'NORMAL'] || 0) ||
+        timeOf(right) - timeOf(left) ||
+        reminderReceiptId(left).localeCompare(reminderReceiptId(right)));
+}
+/**
+ * 独立于 React 的当前账号提醒队列。
+ * 轮询重复返回同一收件记录时不会重复创建提醒，尚未真正显示的排队消息不能提前记为已提醒。
+ */
+export class ReminderQueue {
+    constructor(remembered = [], capacity = 1000) {
+        this.capacity = capacity;
+        this.records = new Map();
+        this.seen = new Set(remembered);
+    }
+    ingest(messages, now = Date.now()) {
+        for (const record of messages) {
+            const id = reminderReceiptId(record);
+            if (!id)
+                continue;
+            if (record.readAt || reminderHasExpired(record, now)) {
+                this.records.delete(id);
+                continue;
+            }
+            if (!this.records.has(id) && this.seen.has(id))
+                continue;
+            this.records.set(id, record);
+        }
+        // 限制内存占用；未展示的低优先级记录被移出队列后仍未被记住，后续扫描可再次接入。
+        // 每轮继续读取最新一页，新的严重消息不会被历史普通消息堵住。
+        const ordered = this.messages(now);
+        for (const record of ordered.slice(this.capacity))
+            this.records.delete(reminderReceiptId(record));
+    }
+    messages(now = Date.now()) {
+        for (const [id, record] of this.records) {
+            if (record.readAt || reminderHasExpired(record, now))
+                this.records.delete(id);
+        }
+        return [...this.records.values()].sort(compareReminders);
+    }
+    /** 完整未读投影查询成功后移除缺失记录；分页中途失败时调用方不能进行这一步。 */
+    retainUnread(ids) {
+        const unread = new Set(ids);
+        for (const [id, record] of this.records)
+            if (!isReminderPreview(record) && !unread.has(id))
+                this.records.delete(id);
+    }
+    presented(record) {
+        // 全屏提醒必须明确确认；刷新页面不能用“曾经显示过”绕过未读确认。
+        if (isReminderPreview(record) || record.reminderMode === 'FULLSCREEN')
+            return false;
+        const id = reminderReceiptId(record);
+        const changed = !this.seen.has(id);
+        this.seen.add(id);
+        return changed;
+    }
+    dismiss(id) {
+        this.records.delete(id);
+        if (!id.startsWith('preview:'))
+            this.seen.add(id);
+    }
+    preview(record) {
+        for (const [id, item] of this.records)
+            if (isReminderPreview(item))
+                this.records.delete(id);
+        this.records.set(reminderReceiptId(record), record);
+    }
+    remembered() {
+        // 存储仅含收件标识，不存正文、账号凭证或来源业务属性。
+        return [...this.seen].slice(-5000);
+    }
+}