@pmate/chat-sdk 0.12.0-next.59 → 0.12.0-next.60

package/lib/runtime/groupClient.js

@@ -0,0 +1,325 @@
+import { IndexedDbResponseCache } from "./responseCache.js";
+import { WindowedTasks } from "./coalescer.js";
+import { isOffline } from "./connectivity.js";
+import { messageScopeKey } from "./messageStore.js";
+import { validateConversation, validMessageIdentifier } from "./outgoingContent.js";
+const empty = Object.freeze({ loading: false });
+const token = (value) => `${value?.versionNumber}:${value?.revision}`;
+/** SDK-owned roster cache. Read sources, concurrency and reconciliation stay private. */
+export class GroupClient {
+    options;
+    cache;
+    entries = new Map();
+    pins = new Map();
+    listeners = new Set();
+    localQueue = [];
+    localScheduled = false;
+    localRunning = new Set();
+    tasks;
+    authority;
+    version;
+    clock = 0;
+    active = 0;
+    queue = [];
+    controllers = new Set();
+    channel;
+    withdrawn = false;
+    closed = false;
+    closing;
+    constructor(options) {
+        this.options = options;
+        const scope = JSON.stringify(["groups", messageScopeKey(options.scope)]);
+        this.options = { ...options, scope: { ...options.scope } };
+        this.cache = new IndexedDbResponseCache(scope, { indexedDB: options.indexedDB, name: options.name, access: () => this.checkAuthority(), entries: 64, batchRecords: 32, recordBytes: 131072, revision: token });
+        this.tasks = new WindowedTasks(200, error => { if (!this.closed)
+            options.onError(error); });
+        if (typeof BroadcastChannel !== "undefined") {
+            this.channel = new BroadcastChannel(`pmate-chat-groups:${scope}:${options.name ?? "default"}`);
+            this.channel.onmessage = event => {
+                if (event.data?.authority !== this.version || typeof event.data?.threadId !== "string")
+                    return;
+                const entry = this.entries.get(event.data.threadId);
+                if (entry)
+                    void this.reload(entry).catch(error => { if (!this.closed)
+                        options.onError(error); });
+            };
+        }
+    }
+    assertOpen() { if (this.closed)
+        throw new Error("GROUP_CLIENT_CLOSED"); if (this.withdrawn)
+        throw new Error("GROUP_ACCESS_REVOKED"); }
+    checkAuthority() {
+        if (this.withdrawn)
+            throw new Error("GROUP_ACCESS_REVOKED");
+        if (this.authority)
+            return this.authority;
+        return this.authority = this.options.access().then(access => {
+            if (this.withdrawn)
+                throw new Error("GROUP_ACCESS_REVOKED");
+            if (!access.allowed) {
+                this.withdraw();
+                throw new Error("GROUP_ACCESS_REVOKED");
+            }
+            if (this.version !== undefined && this.version !== access.version) {
+                this.withdraw();
+                throw new Error("GROUP_SCOPE_CHANGED");
+            }
+            this.version = access.version;
+            return access;
+        }).finally(() => { this.authority = undefined; });
+    }
+    entry(thread) {
+        this.assertOpen();
+        validateConversation(this.options.scope, thread);
+        if (thread.kind !== "group")
+            throw new Error("INVALID_GROUP_CONVERSATION");
+        let entry = this.entries.get(thread.id);
+        if (!entry) {
+            if (this.entries.size >= 256) {
+                const old = [...this.entries.values()].filter(value => !value.local && !value.request && !this.pins.has(value.thread.id)).sort((a, b) => a.used - b.used)[0];
+                if (!old)
+                    throw new Error("GROUP_CACHE_BACKPRESSURE");
+                this.entries.delete(old.thread.id);
+            }
+            entry = { thread: { id: thread.id, kind: "group", targetId: thread.targetId, teamId: thread.teamId }, snapshot: empty, epoch: 0, token: null, loaded: false, checked: false, generation: 0, wanted: 0, attempts: 0, used: 0 };
+            this.entries.set(thread.id, entry);
+        }
+        entry.used = ++this.clock;
+        return entry;
+    }
+    snapshot(threadId) { return this.closed || this.withdrawn ? empty : this.entries.get(threadId)?.snapshot ?? empty; }
+    subscribe(listener) { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }
+    pin(threadId) { this.pins.set(threadId, (this.pins.get(threadId) ?? 0) + 1); return () => { const count = (this.pins.get(threadId) ?? 1) - 1; if (count)
+        this.pins.set(threadId, count);
+    else
+        this.pins.delete(threadId); }; }
+    publish(entry, next) {
+        if (this.closed)
+            return;
+        const previous = entry.snapshot;
+        if (previous.data && next.data && JSON.stringify(previous.data) === JSON.stringify(next.data))
+            next = { ...next, data: previous.data };
+        if (previous.data === next.data && previous.loading === next.loading && previous.error === next.error)
+            return;
+        entry.snapshot = Object.freeze(next);
+        this.listeners.forEach(listener => listener(entry.thread.id));
+    }
+    normalize(value, entry) {
+        const scope = this.options.scope;
+        if (!value || value.appId !== scope.appId || value.groupId !== entry.thread.targetId || value.teamId !== scope.teamId || !validMessageIdentifier(value.ownerId) || !validMessageIdentifier(value.revision) || !Number.isSafeInteger(value.versionNumber) || value.versionNumber < 1 || !Array.isArray(value.members) || !value.members.length || value.members.length > 256 || !value.members.every(validMessageIdentifier) || !value.members.includes(value.ownerId) || !value.members.includes(scope.profileId) || typeof value.title !== "string" || value.avatar !== undefined && value.avatar !== null && typeof value.avatar !== "string")
+            throw new Error("INVALID_GROUP_METADATA");
+        return Object.freeze({ groupId: value.groupId, teamId: scope.teamId, ownerId: value.ownerId, title: value.title, ...(value.avatar ? { avatar: value.avatar } : {}), memberIds: Object.freeze([...new Set(value.members)].sort()), revision: value.revision, versionNumber: value.versionNumber });
+    }
+    cached(value, entry) {
+        return this.normalize({ appId: this.options.scope.appId, groupId: value?.groupId, teamId: value?.teamId, ownerId: value?.ownerId, title: value?.title, avatar: value?.avatar, members: value?.memberIds, revision: value?.revision, versionNumber: value?.versionNumber }, entry);
+    }
+    local(entry) {
+        if (entry.loaded)
+            return Promise.resolve();
+        if (entry.local)
+            return entry.local;
+        this.publish(entry, { ...entry.snapshot, loading: !entry.snapshot.data });
+        entry.local = new Promise((resolve, reject) => this.localQueue.push({ entry, resolve, reject })).finally(() => { entry.local = undefined; });
+        if (!this.localScheduled) {
+            this.localScheduled = true;
+            queueMicrotask(() => { this.localScheduled = false; void this.flushLocal(); });
+        }
+        return entry.local;
+    }
+    flushLocal() {
+        const task = (async () => {
+            while (this.localQueue.length) {
+                const batch = this.localQueue.splice(0, 128);
+                try {
+                    this.assertOpen();
+                    await this.checkAuthority();
+                    const rows = await this.cache.readMany(batch.map(item => item.entry.thread.id));
+                    await this.checkAuthority();
+                    this.assertOpen();
+                    for (const item of batch) {
+                        try {
+                            const row = rows.get(item.entry.thread.id), entry = item.entry;
+                            let data = row.cached ? this.cached(row.cached.value, entry) : undefined;
+                            const old = entry.snapshot.data;
+                            if (old && data && old.versionNumber > data.versionNumber)
+                                data = old;
+                            if (old && data && old.versionNumber === data.versionNumber && JSON.stringify(old) !== JSON.stringify(data))
+                                throw new Error("GROUP_REVISION_CONFLICT");
+                            entry.epoch = row.epoch;
+                            entry.token = row.cached ? token(row.cached.value) : null;
+                            entry.loaded = true;
+                            this.publish(entry, { data: data ?? old, loading: false });
+                            item.resolve();
+                        }
+                        catch (error) {
+                            this.publish(item.entry, { ...item.entry.snapshot, loading: false, error });
+                            item.reject(error);
+                        }
+                    }
+                }
+                catch (error) {
+                    for (const item of batch) {
+                        this.publish(item.entry, { loading: false, error });
+                        item.reject(error);
+                    }
+                }
+            }
+        })().finally(() => this.localRunning.delete(task));
+        this.localRunning.add(task);
+        return task;
+    }
+    async reload(entry) { entry.loaded = false; await this.local(entry); }
+    async get(thread, options = {}) {
+        const entry = this.entry(thread);
+        await this.local(entry);
+        await this.checkAuthority();
+        this.assertOpen();
+        if (entry.snapshot.data && !options.refresh) {
+            if (!entry.checked && !isOffline())
+                this.schedule(entry);
+            return entry.snapshot.data;
+        }
+        if (isOffline())
+            throw entry.snapshot.error ?? new Error("GROUP_METADATA_OFFLINE");
+        return this.request(entry);
+    }
+    schedule(entry) { if (!this.closed && !this.withdrawn && !isOffline())
+        this.tasks.schedule(entry.thread.id, async () => { await this.get(entry.thread, { refresh: true }); }); }
+    wake() { for (const entry of this.entries.values())
+        this.schedule(entry); }
+    hint(thread, versionNumber) {
+        const entry = this.entries.get(thread.id);
+        if (!entry || this.closed || this.withdrawn || versionNumber !== undefined && versionNumber <= (entry.snapshot.data?.versionNumber ?? 0))
+            return;
+        entry.generation++;
+        entry.attempts = 0;
+        entry.wanted = Math.max(entry.wanted, versionNumber ?? 0);
+        this.schedule(entry);
+    }
+    slot(run) {
+        if (this.queue.length >= 128)
+            return Promise.reject(new Error("GROUP_NETWORK_BACKPRESSURE"));
+        return new Promise((resolve, reject) => { this.queue.push({ run, resolve, reject }); this.drain(); });
+    }
+    drain() {
+        while (!this.closed && this.active < 4 && this.queue.length) {
+            const work = this.queue.shift();
+            this.active++;
+            void work.run().then(work.resolve, work.reject).finally(() => { this.active--; this.drain(); });
+        }
+    }
+    request(entry) {
+        if (entry.request)
+            return entry.request;
+        const task = this.slot(async () => {
+            this.assertOpen();
+            await this.checkAuthority();
+            const base = entry.token, generation = entry.generation, controller = new AbortController();
+            this.controllers.add(controller);
+            const timer = setTimeout(() => controller.abort(), 5000);
+            this.publish(entry, { ...entry.snapshot, loading: !entry.snapshot.data, error: undefined });
+            try {
+                const value = this.normalize(await this.options.load(entry.thread.targetId, controller.signal), entry);
+                await this.checkAuthority();
+                this.assertOpen();
+                if (entry.snapshot.data && value.versionNumber <= entry.snapshot.data.versionNumber)
+                    await this.reload(entry);
+                const old = entry.snapshot.data;
+                if (old && value.versionNumber < old.versionNumber) {
+                    this.publish(entry, { data: old, loading: false });
+                    return old;
+                }
+                if (old && value.versionNumber === old.versionNumber) {
+                    if (value.revision !== old.revision || JSON.stringify(value) !== JSON.stringify(old))
+                        throw new Error("GROUP_REVISION_CONFLICT");
+                    entry.checked = true;
+                    this.publish(entry, { data: old, loading: false });
+                    return old;
+                }
+                try {
+                    await this.cache.write(entry.thread.id, value, entry.epoch, base);
+                }
+                catch (error) {
+                    if (!String(error).includes("RESPONSE_CACHE_CHANGED"))
+                        throw error;
+                    await this.reload(entry);
+                    this.schedule(entry);
+                    if (entry.snapshot.data)
+                        return entry.snapshot.data;
+                    throw error;
+                }
+                await this.checkAuthority();
+                this.assertOpen();
+                entry.token = token(value);
+                entry.checked = true;
+                this.publish(entry, { data: value, loading: false });
+                this.channel?.postMessage({ threadId: entry.thread.id, authority: this.version });
+                return value;
+            }
+            catch (error) {
+                if (!this.closed) {
+                    const denied = [401, 403].includes(error?.status ?? 0);
+                    this.publish(entry, { data: denied ? undefined : entry.snapshot.data, loading: false, error });
+                    if (denied)
+                        await this.options.onDenied?.(error);
+                }
+                throw error;
+            }
+            finally {
+                clearTimeout(timer);
+                this.controllers.delete(controller);
+                if (!this.closed && (generation !== entry.generation || entry.wanted > (entry.snapshot.data?.versionNumber ?? 0)) && entry.attempts++ < 4)
+                    this.schedule(entry);
+            }
+        }).finally(() => { if (entry.request === task)
+            entry.request = undefined; });
+        entry.request = task;
+        return task;
+    }
+    async after(thread, minimumVersion) {
+        if (!Number.isSafeInteger(minimumVersion) || minimumVersion < 1)
+            throw new Error("INVALID_GROUP_VERSION");
+        const entry = this.entry(thread);
+        for (const delay of [0, 200, 400, 800, 1600]) {
+            if (entry.snapshot.data && entry.snapshot.data.versionNumber >= minimumVersion)
+                return entry.snapshot.data;
+            if (delay)
+                await new Promise(resolve => setTimeout(resolve, delay));
+            this.assertOpen();
+            try {
+                const value = await this.get(thread, { refresh: true });
+                if (value.versionNumber >= minimumVersion)
+                    return value;
+            }
+            catch (error) {
+                if (this.closed || this.withdrawn || isOffline() || ![503].includes(error?.status ?? 0))
+                    throw error;
+            }
+        }
+        throw new Error("GROUP_SYNC_PENDING");
+    }
+    withdraw() { this.withdrawn = true; this.tasks.close(); this.controllers.forEach(controller => controller.abort()); for (const entry of this.entries.values())
+        this.publish(entry, { loading: false, error: new Error("GROUP_ACCESS_REVOKED") }); }
+    retire(version) { this.withdraw(); return this.cache.retire(version); }
+    close() {
+        if (this.closing)
+            return this.closing;
+        this.closed = true;
+        this.tasks.close();
+        this.channel?.close();
+        this.controllers.forEach(controller => controller.abort());
+        this.listeners.clear();
+        const error = new Error("GROUP_CLIENT_CLOSED");
+        this.queue.splice(0).forEach(work => work.reject(error));
+        this.localQueue.splice(0).forEach(work => work.reject(error));
+        return this.closing = (async () => { try {
+            await Promise.allSettled([...this.entries.values()].flatMap(entry => entry.request ? [entry.request] : []));
+            await Promise.allSettled([...this.localRunning]);
+            await this.cache.close();
+        }
+        finally {
+            this.entries.clear();
+            this.pins.clear();
+        } })();
+    }
+}

package/lib/runtime/index.d.ts

@@ -34,3 +34,4 @@ export { projectConversationReading, type ReadingCandidate, type MessageReadingS
 export { projectMessageTimeline, type TimelineItem, type TimelineReaction, type TimelineReactionEvent } from "./messageTimeline.js";
 export * from "./messageLaunch.js";
 export * from "./outgoingContent.js";
+export type { ChatGroup } from "./groupClient.js";

package/lib/runtime/outboxSchema.js

@@ -54,5 +54,6 @@ export function outboxDatabase(factory, name) {
     db.version(2).stores({ scopeEpochs: "scope" });
     db.version(3).stores({ outbox: messageSchema });
     db.version(4).stores({ outbox: "unsupportedOutboxFormat", outgoingMessages: messageSchema, outgoingAttachments: "[scope+hash],scope" });
+    db.version(5).stores({ outgoingControls: "[scope+threadId+target+emoji],scope" });
     return db;
 }

package/lib/runtime/outgoingContent.d.ts

@@ -13,35 +13,73 @@ export type MessageQuote = {
     senderName: string;
     content: string;
 };
-export type OutgoingContent = {
-    text: string;
-    mentions?: ChatMention[];
-    quote?: MessageQuote;
-    image?: never;
-    voice?: never;
-} | {
+type ContentChoices = {
+    text: {
+        text: string;
+        mentions?: ChatMention[];
+        quote?: MessageQuote;
+    };
     image: {
-        url: string;
-        name?: string;
-    };
-    text?: never;
-    voice?: never;
-} | {
-    voice: ({
-        blob: Blob;
-        url?: never;
-    } | {
-        url: string;
-        blob?: never;
-    }) & {
-        durationMs: number;
-        transcript?: string;
-    };
-    text?: never;
-    image?: never;
+        image: {
+            url: string;
+            name?: string;
+        };
+    };
+    voice: {
+        voice: ({
+            blob: Blob;
+            url?: never;
+        } | {
+            url: string;
+            blob?: never;
+        }) & {
+            durationMs: number;
+            transcript?: string;
+        };
+    };
+    recall: {
+        recall: {
+            messageId: string;
+        };
+    };
+    reaction: {
+        reaction: {
+            messageId: string;
+            emojiId: string;
+            active: boolean;
+        };
+    };
+    invitation: {
+        invitation: {
+            message?: string;
+        };
+    };
+    groupCreate: {
+        groupCreate: {
+            title: string;
+            members: readonly string[];
+        };
+    };
+    groupUpdate: {
+        groupUpdate: {
+            expectedRevision: string;
+            addMembers?: readonly string[];
+            removeMembers?: readonly string[];
+            title?: string;
+            avatar?: string;
+        };
+    };
 };
+export type OutgoingContent = {
+    [K in keyof ContentChoices]: ContentChoices[K] & {
+        [P in Exclude<keyof ContentChoices, K>]?: never;
+    };
+}[keyof ContentChoices];
+export declare function validMessageIdentifier(value: unknown): value is string;
+export declare function validateConversation(scope: MessageScope, thread: ChatConversation): void;
 export declare const ALL_MENTION_ID = "__pmate_mention_all__";
 /** Expand group mentions into concrete members understood by all protocol readers. */
 export declare function expandGroupMentions(text: string, mentions: ChatMention[] | undefined, memberIds: readonly string[], senderId: string): ChatMention[];
 /** Build the existing wire protocol inside the owner, before durable acceptance. */
 export declare function outgoingContent(scope: MessageScope, thread: ChatConversation, input: OutgoingContent): SendMessageInput;
+export {};

package/lib/runtime/outgoingContent.js

@@ -1,4 +1,18 @@
 import { dmThreadId, groupThreadId } from "./thread.js";
+const contentKeys = ["text", "image", "voice", "recall", "reaction", "invitation", "groupCreate", "groupUpdate"];
+export function validMessageIdentifier(value) { return typeof value === "string" && value.length > 0 && new TextEncoder().encode(value).byteLength <= 256 && !/[\u0000-\u001f]/u.test(value); }
+function members(value) {
+    if (!Array.isArray(value) || value.length > 256 || !value.every(validMessageIdentifier))
+        throw new Error("INVALID_GROUP_MEMBERS");
+    return [...new Set(value)].sort();
+}
+export function validateConversation(scope, thread) {
+    if (!thread || !["dm", "group"].includes(thread.kind) || !validMessageIdentifier(thread.targetId) || thread.teamId !== undefined && thread.teamId !== scope.teamId)
+        throw new Error("INVALID_MESSAGE_CONVERSATION");
+    const expected = thread.kind === "group" ? groupThreadId(scope.appId, thread.targetId, scope.teamId) : dmThreadId(scope.appId, scope.profileId, thread.targetId, scope.teamId);
+    if (thread.id !== expected)
+        throw new Error("MESSAGE_CONVERSATION_MISMATCH");
+}
 export const ALL_MENTION_ID = "__pmate_mention_all__";
 /** Expand group mentions into concrete members understood by all protocol readers. */
 export function expandGroupMentions(text, mentions, memberIds, senderId) {
@@ -21,17 +35,51 @@ export function expandGroupMentions(text, mentions, memberIds, senderId) {
 }
 /** Build the existing wire protocol inside the owner, before durable acceptance. */
 export function outgoingContent(scope, thread, input) {
-    if (!thread || !["dm", "group"].includes(thread.kind) || typeof thread.targetId !== "string" || !thread.targetId || thread.teamId !== undefined && thread.teamId !== scope.teamId)
-        throw new Error("INVALID_MESSAGE_CONVERSATION");
-    const expected = thread.kind === "group" ? groupThreadId(scope.appId, thread.targetId, scope.teamId) : dmThreadId(scope.appId, scope.profileId, thread.targetId, scope.teamId);
-    if (thread.id !== expected)
-        throw new Error("MESSAGE_CONVERSATION_MISMATCH");
+    validateConversation(scope, thread);
+    if (!input || typeof input !== "object" || contentKeys.filter(key => Object.hasOwn(input, key)).length !== 1)
+        throw new Error("INVALID_MESSAGE_CONTENT");
+    const identity = { appId: scope.appId, teamId: scope.teamId };
+    if (input.invitation) {
+        if (typeof input.invitation !== "object" || Array.isArray(input.invitation) || thread.kind !== "dm" || input.invitation.message !== undefined && typeof input.invitation.message !== "string")
+            throw new Error("INVALID_MESSAGE_INVITATION");
+        return { to: thread.targetId, body: { kind: "contact", threadKind: "dm", action: "friendRequest", payload: { ...identity, message: input.invitation.message ?? "" } } };
+    }
+    if (input.groupCreate) {
+        if (thread.kind !== "group" || typeof input.groupCreate.title !== "string")
+            throw new Error("INVALID_GROUP_CREATE");
+        const recipients = members(input.groupCreate.members);
+        if (new Set([scope.profileId, ...recipients]).size > 256)
+            throw new Error("INVALID_GROUP_MEMBERS");
+        return { to: thread.targetId, recipients, body: { kind: "group", threadKind: "group", action: "groupCreate", payload: { ...identity, groupId: thread.targetId, title: input.groupCreate.title, members: recipients } } };
+    }
+    if (input.groupUpdate) {
+        const update = input.groupUpdate, add = members(update.addMembers ?? []), remove = members(update.removeMembers ?? []);
+        if (thread.kind !== "group" || !validMessageIdentifier(update.expectedRevision) || Number(add.length > 0) + Number(remove.length > 0) + Number(update.title !== undefined) + Number(update.avatar !== undefined) !== 1)
+            throw new Error("INVALID_GROUP_UPDATE");
+        if (update.title !== undefined && (typeof update.title !== "string" || !update.title.trim() || [...update.title.trim()].length > 120))
+            throw new Error("INVALID_GROUP_TITLE");
+        if (update.avatar !== undefined && (typeof update.avatar !== "string" || !update.avatar.startsWith("https://") || update.avatar.length > 2048 || /\s/u.test(update.avatar)))
+            throw new Error("INVALID_GROUP_AVATAR");
+        return { to: thread.targetId, body: { kind: "group", threadKind: "group", action: "groupUpdate", payload: { ...identity, groupId: thread.targetId, expectedRevision: update.expectedRevision, addMembers: add, removeMembers: remove, ...(update.title === undefined ? {} : { title: update.title.trim() }), ...(update.avatar === undefined ? {} : { avatar: update.avatar }) } } };
+    }
+    if (thread.kind === "group" && !Array.isArray(thread.memberIds))
+        throw new Error("MESSAGE_GROUP_MEMBERS_UNAVAILABLE");
     const recipients = thread.kind === "group" ? [...new Set(thread.memberIds)] : undefined;
-    if (recipients && (!recipients.length || recipients.some(id => typeof id !== "string" || !id)))
+    if (recipients && (!recipients.length || recipients.length > 256 || !recipients.every(validMessageIdentifier)))
         throw new Error("MESSAGE_GROUP_MEMBERS_UNAVAILABLE");
-    const base = { appId: scope.appId, ...(scope.teamId === undefined ? {} : { teamId: scope.teamId }), ...(thread.kind === "group" ? { groupId: thread.targetId } : {}) };
-    if (!input || typeof input !== "object" || ["text", "image", "voice"].filter(key => Object.hasOwn(input, key)).length !== 1)
-        throw new Error("INVALID_MESSAGE_CONTENT");
+    const base = { ...identity, ...(thread.kind === "group" ? { groupId: thread.targetId } : {}) };
+    if (input.recall) {
+        if (!validMessageIdentifier(input.recall.messageId))
+            throw new Error("INVALID_MESSAGE_RECALL");
+        return { to: thread.targetId, ...(recipients ? { recipients } : {}), body: { kind: "message", threadKind: thread.kind, contentKind: "text", content: { ...identity, text: "[消息已撤回]", recall: { messageId: input.recall.messageId } } } };
+    }
+    if (input.reaction) {
+        const reaction = input.reaction;
+        if (!validMessageIdentifier(reaction.messageId) || !validMessageIdentifier(reaction.emojiId) || typeof reaction.active !== "boolean")
+            throw new Error("INVALID_MESSAGE_REACTION");
+        // The durable sender assigns the revision in the acceptance transaction.
+        return { to: thread.targetId, ...(recipients ? { recipients } : {}), body: { kind: "message", threadKind: thread.kind, contentKind: "text", content: { ...identity, text: "[表情回应]", reaction: { version: 1, messageId: reaction.messageId, emojiId: reaction.emojiId, active: reaction.active, revision: 1 } } } };
+    }
     let content, contentKind = "text", voiceBlob;
     if ("text" in input) {
         if (typeof input.text !== "string")

package/lib/runtime/responseCache.d.ts

@@ -4,6 +4,15 @@ export type ResponseCacheAccess = () => Promise<{
 }>;
 export declare function isResponseCacheAuthorityError(error: unknown): boolean;
 export declare function assertResponseCacheAccess(access?: ResponseCacheAccess, expectedVersion?: number): Promise<number | undefined>;
+export type ResponseCacheOptions<T> = {
+    indexedDB?: IDBFactory;
+    name?: string;
+    access?: ResponseCacheAccess;
+    recordBytes?: number;
+    entries?: number;
+    batchRecords?: number;
+    revision?: (value: T) => string;
+};
 /** Small response windows, isolated by identity. Epochs fence late writes after
  * access withdrawal. No localStorage or synchronous writes on the read path. */
 export declare class IndexedDbResponseCache<T> {
@@ -18,11 +27,7 @@ export declare class IndexedDbResponseCache<T> {
     private invalidations;
     private closed;
     private closing?;
-    constructor(scope: string, options?: {
-        indexedDB?: IDBFactory;
-        name?: string;
-        access?: ResponseCacheAccess;
-    });
+    constructor(scope: string, options?: ResponseCacheOptions<T>);
     /** Resolve shared message-scope authority before opening our transaction.
      * A newer authority version retires response windows exactly once; delayed
      * callers can never roll the authority backwards or delete recovered data. */
@@ -34,7 +39,15 @@ export declare class IndexedDbResponseCache<T> {
             time: number;
         } | undefined;
     }>;
-    write(key: string, value: T, epoch: number): Promise<void>;
+    /** Key-only callers can share one bounded metadata read transaction. */
+    readMany(keys: readonly string[]): Promise<Map<string, {
+        epoch: number;
+        cached: {
+            value: T;
+            time: number;
+        } | undefined;
+    }>>;
+    write(key: string, value: T, epoch: number, expectedRevision?: string | null): Promise<void>;
     /** Idempotent shared-scope retirement: an old cleanup cannot erase windows
      * created after the same authority version was already recovered. */
     retire(version: number): Promise<void>;