@pmate/chat-sdk 0.12.0-next.40 → 0.12.0-next.41

package/lib/runtime/cachedMessage.d.ts

@@ -0,0 +1,12 @@
+import type { ChatReaderSocialMessage } from "./readerClient.js";
+import type { ChatRuntimeMessage } from "./protocol.js";
+export type CachedChatMessage = ChatReaderSocialMessage & {
+    id: string;
+    timestamp: number;
+    readPolicy?: "visible" | "explicit";
+};
+export declare function decodeCachedChatMessage(message: ChatRuntimeMessage, scope: {
+    appId: string;
+    profileId: string;
+    teamId: string;
+}): CachedChatMessage | undefined;

package/lib/runtime/cachedMessage.js

@@ -0,0 +1,18 @@
+import { chatTeamId } from "./teamScope.js";
+import { dmThreadId, groupThreadId } from "./thread.js";
+export function decodeCachedChatMessage(message, scope) {
+    if (message.opcode !== 1 || !message.body || typeof message.body !== "object")
+        return;
+    const body = message.body;
+    const invitation = body.kind === "contact" && ["friendRequest", "requestFriend"].includes(String(body.action));
+    if ((!invitation && body.kind !== "message") || (invitation ? body.payload?.appId : body.content?.appId) !== scope.appId || chatTeamId(body) !== scope.teamId)
+        return;
+    const threadKind = invitation ? "dm" : body.threadKind;
+    if (threadKind !== "dm" && threadKind !== "group")
+        return;
+    if (threadKind === "dm" && message.from !== scope.profileId && message.to !== scope.profileId)
+        return;
+    const threadId = threadKind === "dm" ? dmThreadId(scope.appId, message.from, message.to, scope.teamId) : groupThreadId(scope.appId, message.to, scope.teamId);
+    return { appId: scope.appId, teamId: scope.teamId, threadId, threadKind, messageId: message.hash, id: message.hash,
+        timestamp: message.t, serverCreatedAt: message.t, clientCreatedAt: message.t, from: message.from, to: message.to, body: message.body, recipients: message.recipients };
+}

package/lib/runtime/createChat.d.ts

@@ -1,11 +1,7 @@
 import { ChatSession } from "./chatSession.js";
-import type { ChatReaderSocialMessage } from "./readerClient.js";
 import type { ChatClient, ChatClientOptions } from "./chatClient.js";
-export type CachedChatMessage = ChatReaderSocialMessage & {
-    id: string;
-    timestamp: number;
-    readPolicy?: "visible" | "explicit";
-};
+import { type CachedChatMessage } from "./cachedMessage.js";
+export type { CachedChatMessage } from "./cachedMessage.js";
 export type CreateChatOptions = {
     appId: string;
     accountId: string;

package/lib/runtime/createChat.js

@@ -1,8 +1,8 @@
 import { isReadingControl, messageRequiresPlayback, messageMentionsProfile } from "./readingContent.js";
 import { ChatSession } from "./chatSession.js";
 import { SocialReadClient } from "./socialReadClient.js";
-import { chatTeamId } from "./teamScope.js";
-import { dmThreadId, groupThreadId, isValidChatTeamId } from "./thread.js";
+import { isValidChatTeamId } from "./thread.js";
+import { decodeCachedChatMessage } from "./cachedMessage.js";
 /** Standard browser entry: storage, paging, realtime and reading share one identity. */
 export function createChat(options) {
     const { appId, accountId, profileId, teamId, token, onError } = options;
@@ -31,22 +31,6 @@ export function createChat(options) {
             return { id: message.id, threadId: message.threadId, from: message.from, mine: message.from === profileId, recalled: message.recalled, unread: message.from !== profileId,
                 readPolicy: message.readPolicy === "explicit" || message.legacyDisplay?.kind === "voice" || messageRequiresPlayback(body) ? "explicit" : "visible", attentionEligible: messageMentionsProfile(body, profileId) };
         },
-        decode: message => decodeIncoming(message, { appId, profileId, teamId }), onError,
+        decode: message => decodeCachedChatMessage(message, { appId, profileId, teamId }), onError,
     });
 }
-function decodeIncoming(message, scope) {
-    if (message.opcode !== 1 || !message.body || typeof message.body !== "object")
-        return;
-    const body = message.body;
-    const invitation = body.kind === "contact" && ["friendRequest", "requestFriend"].includes(String(body.action));
-    if ((!invitation && body.kind !== "message") || (invitation ? body.payload?.appId : body.content?.appId) !== scope.appId || chatTeamId(body) !== scope.teamId)
-        return;
-    const threadKind = invitation ? "dm" : body.threadKind;
-    if (threadKind !== "dm" && threadKind !== "group")
-        return;
-    if (threadKind === "dm" && message.from !== scope.profileId && message.to !== scope.profileId)
-        return;
-    const threadId = threadKind === "dm" ? dmThreadId(scope.appId, message.from, message.to, scope.teamId) : groupThreadId(scope.appId, message.to, scope.teamId);
-    return { appId: scope.appId, teamId: scope.teamId, threadId, threadKind, messageId: message.hash, id: message.hash,
-        timestamp: message.t, serverCreatedAt: message.t, clientCreatedAt: message.t, from: message.from, to: message.to, body: message.body, recipients: message.recipients };
-}

package/lib/runtime/durableSender.d.ts

@@ -44,6 +44,8 @@ export declare class DurableChatSender {
     private offConnection;
     private ready;
     constructor(client: ChatClient, scope: MessageScope, onError: (error: unknown) => void, options?: DurableSenderOptions);
+    /** Read only the selected durable rows, without restoring or delivering an outbox. */
+    static readSelected(scope: MessageScope, threadId: string, ids: readonly string[], version: number, options?: Pick<DurableSenderOptions, "indexedDB" | "name">): Promise<OutgoingMessage[]>;
     private readAccess;
     private restore;
     private checkAccess;

package/lib/runtime/durableSender.js

@@ -49,6 +49,25 @@ export class DurableChatSender {
                 void this.resume().catch(onError);
         });
     }
+    /** Read only the selected durable rows, without restoring or delivering an outbox. */
+    static async readSelected(scope, threadId, ids, version, options = {}) {
+        if (ids.length > 100)
+            throw new Error("INVALID_OUTBOX_SELECTION");
+        const key = messageScopeKey(scope), db = new Dexie(options.name ?? "pmate-chat-outbox", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
+        db.version(1).stores({ outbox: "[scope+hash],scope,[scope+threadId]" });
+        db.version(2).stores({ scopeEpochs: "scope" });
+        try {
+            return await db.transaction("r", db.table("outbox"), db.table("scopeEpochs"), async () => {
+                if (((await db.table("scopeEpochs").get(key))?.version ?? 0) !== version)
+                    return [];
+                const rows = await db.table("outbox").bulkGet(ids.map(id => [key, id]));
+                return rows.flatMap(row => row && row.scope === key && row.threadId === threadId && !row.confirmed && (row.accessVersion ?? 0) === version ? [row] : []);
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
     async readAccess() {
         const access = await this.options.access?.();
         if (access && (!Number.isSafeInteger(access.version) || access.version < 0 || typeof access.allowed !== "boolean"))

package/lib/runtime/index.d.ts

@@ -32,3 +32,4 @@ export * from "./createChat.js";
 export * from "./conversationRead.js";
 export { projectConversationReading, type ReadingCandidate, type MessageReadingState, type ConversationReadingView } from "./conversationReading.js";
 export { projectMessageTimeline, type TimelineItem, type TimelineReaction, type TimelineReactionEvent } from "./messageTimeline.js";
+export * from "./messageLaunch.js";

package/lib/runtime/index.js

@@ -32,3 +32,4 @@ export * from "./createChat.js";
 export * from "./conversationRead.js";
 export { projectConversationReading } from "./conversationReading.js";
 export { projectMessageTimeline } from "./messageTimeline.js";
+export * from "./messageLaunch.js";

package/lib/runtime/messageLaunch.d.ts

@@ -0,0 +1,42 @@
+import { type MessageScope } from "./messageStore.js";
+import { type CachedChatMessage } from "./cachedMessage.js";
+import { type TimelineItem } from "./messageTimeline.js";
+export type MessageLaunchMetadata = {
+    title: string;
+    subtitle?: string;
+    kind: "dm" | "group";
+    peerId: string;
+};
+export type MessageLaunchView = {
+    openId: string;
+    threadId: string;
+    metadata: MessageLaunchMetadata;
+    images: Record<string, string>;
+    timeline: readonly TimelineItem<CachedChatMessage>[];
+};
+type Options = {
+    indexedDB?: IDBFactory;
+    name?: string;
+    messagesName?: string;
+    outboxName?: string;
+};
+/** A short-lived ticket contains references and display metadata, never message bodies. */
+export declare function saveMessageLaunch(input: {
+    scope: MessageScope;
+    openId: string;
+    threadId: string;
+    ids: readonly string[];
+    metadata: MessageLaunchMetadata;
+    images?: Readonly<Record<string, string>>;
+}, options?: Options): Promise<boolean>;
+/** Observe one local handoff through canonical message/control and outbox stores.
+ * This host never creates a transport, marks reading, or writes a second body cache. */
+export declare function watchMessageLaunch(input: {
+    scope: MessageScope;
+    openId: string;
+    threadId: string;
+}, onChange: (view: MessageLaunchView | undefined) => void, onError: (error: unknown) => void, options?: Options): {
+    ready: Promise<void>;
+    close: () => void;
+};
+export {};

package/lib/runtime/messageLaunch.js

@@ -0,0 +1,127 @@
+import { Dexie } from "dexie";
+import { IndexedDbMessageStore, messageScopeKey, mergeStoredMessage } from "./messageStore.js";
+import { DurableChatSender } from "./durableSender.js";
+import { decodeCachedChatMessage } from "./cachedMessage.js";
+import { projectMessageTimeline } from "./messageTimeline.js";
+import { WindowedTasks } from "./coalescer.js";
+function tickets(options) {
+    const db = new Dexie(options.name ?? "pmate-chat-launches", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
+    db.version(1).stores({ tickets: "[scope+openId],scope,expiresAt" });
+    return { db, rows: db.table("tickets") };
+}
+function messages(scope, options) { return new IndexedDbMessageStore(scope, mergeStoredMessage, { indexedDB: options.indexedDB, name: options.messagesName }); }
+function valid(value) { return typeof value === "string" && value.length > 0 && value.length <= 256 && !/[\u0000-\u001f]/.test(value); }
+/** A short-lived ticket contains references and display metadata, never message bodies. */
+export async function saveMessageLaunch(input, options = {}) {
+    const { scope, openId, threadId } = input;
+    if (!Object.values(scope).every(valid) || !valid(openId) || !valid(threadId) || input.ids.length > 30 || input.ids.some(id => !valid(id)))
+        throw new Error("INVALID_MESSAGE_LAUNCH");
+    if (!["dm", "group"].includes(input.metadata.kind) || !valid(input.metadata.peerId) || typeof input.metadata.title !== "string")
+        throw new Error("INVALID_MESSAGE_LAUNCH");
+    const store = messages(scope, options), { db, rows } = tickets(options);
+    try {
+        const page = await store.readSelected(threadId, []), coverage = page.coverage;
+        if (!coverage?.complete || coverage.revoked || !input.ids.length)
+            return false;
+        const images = {};
+        for (const [url, data] of Object.entries(input.images ?? {}).slice(-4))
+            if (url.length <= 2048 && data.length <= 65536 && /^data:image\/(webp|png);base64,[A-Za-z0-9+/=]+$/.test(data))
+                images[url] = data;
+        const ticket = { scope: messageScopeKey(scope), openId, threadId, expiresAt: Date.now() + 30_000, scopeVersion: coverage.scopeVersion ?? 0, resetVersion: coverage.resetVersion ?? 0, ids: [...new Set(input.ids)], metadata: { title: input.metadata.title.slice(0, 200), subtitle: input.metadata.subtitle?.slice(0, 200), kind: input.metadata.kind, peerId: input.metadata.peerId }, images };
+        await db.transaction("rw", rows, async () => {
+            await rows.where("expiresAt").below(Date.now()).limit(8).delete();
+            await rows.put(ticket);
+            const excess = await rows.count() - 8;
+            if (excess > 0)
+                await rows.bulkDelete(await rows.orderBy("expiresAt").limit(excess).primaryKeys());
+        });
+        return true;
+    }
+    finally {
+        store.close();
+        db.close();
+    }
+}
+/** Observe one local handoff through canonical message/control and outbox stores.
+ * This host never creates a transport, marks reading, or writes a second body cache. */
+export function watchMessageLaunch(input, onChange, onError, options = {}) {
+    const { scope, openId, threadId } = input, key = messageScopeKey(scope), store = messages(scope, options), { db, rows } = tickets(options);
+    let closed = false, generation = 0, ticket, timer;
+    const channels = [];
+    const stop = () => { if (closed)
+        return; closed = true; generation++; clearTimeout(timer); tasks.close(); channels.forEach(channel => channel.close()); store.close(); db.close(); };
+    const hide = () => { try {
+        if (!closed)
+            onChange(undefined);
+    }
+    finally {
+        stop();
+    } };
+    const fail = (error) => { if (!closed) {
+        try {
+            onError(error);
+        }
+        finally {
+            hide();
+        }
+    } };
+    const refresh = async () => {
+        const run = ++generation;
+        if (!ticket || closed)
+            return;
+        if (ticket.expiresAt <= Date.now()) {
+            hide();
+            return;
+        }
+        const page = await store.readSelected(threadId, ticket.ids), coverage = page.coverage;
+        if (closed || run !== generation)
+            return;
+        if (!coverage?.complete || coverage.revoked || (coverage.scopeVersion ?? 0) !== ticket.scopeVersion || (coverage.resetVersion ?? 0) !== ticket.resetVersion) {
+            hide();
+            return;
+        }
+        const outgoing = await DurableChatSender.readSelected(scope, threadId, ticket.ids, ticket.scopeVersion, { indexedDB: options.indexedDB, name: options.outboxName });
+        const guard = (await store.readSelected(threadId, [])).coverage;
+        if (closed || run !== generation)
+            return;
+        if (!guard?.complete || guard.revoked || (guard.scopeVersion ?? 0) !== ticket.scopeVersion || (guard.resetVersion ?? 0) !== ticket.resetVersion) {
+            hide();
+            return;
+        }
+        const timeline = projectMessageTimeline({ appId: scope.appId, profileId: scope.profileId, threadId, messages: page.messages, outgoing, decode: message => decodeCachedChatMessage(message, scope), reading: {} }).slice(-30);
+        onChange(timeline.length ? { openId, threadId, metadata: ticket.metadata, images: ticket.images, timeline } : undefined);
+    };
+    const tasks = new WindowedTasks(16, fail);
+    if (typeof BroadcastChannel !== "undefined") {
+        const cache = new BroadcastChannel(`pmate-chat:${key}${options.messagesName && options.messagesName !== "pmate-chat-messages" ? `:${options.messagesName}` : ""}`);
+        cache.onmessage = event => {
+            if (event.data?.type === "scope-revoked" || event.data?.type === "revoked" && event.data.thread === threadId) {
+                hide();
+                return;
+            }
+            if (event.data === threadId || event.data?.thread === threadId)
+                tasks.schedule("view", refresh);
+        };
+        channels.push(cache);
+        const outbox = new BroadcastChannel(`pmate-chat-outbox:${key}:${options.outboxName ?? "pmate-chat-outbox"}`);
+        outbox.onmessage = () => tasks.schedule("view", refresh);
+        channels.push(outbox);
+    }
+    const ready = (async () => {
+        ticket = await db.transaction("rw", rows, async () => {
+            const value = await rows.get([key, openId]);
+            if (value)
+                await rows.delete([key, openId]);
+            return value;
+        });
+        if (closed)
+            return;
+        if (!ticket || ticket.scope !== key || ticket.threadId !== threadId || ticket.expiresAt <= Date.now() || ticket.ids.length > 30) {
+            hide();
+            return;
+        }
+        timer = setTimeout(hide, Math.max(0, ticket.expiresAt - Date.now()));
+        await refresh();
+    })().catch(fail);
+    return { ready, close: stop };
+}

package/lib/runtime/messageQuotes.d.ts

@@ -0,0 +1,3 @@
+import type { StoredMessage } from "./messageStore.js";
+export declare function quotedMessageIds(message: StoredMessage): string[];
+export declare function redactMessageQuotes<T extends StoredMessage>(messages: T[], targets: readonly T[]): T[];

package/lib/runtime/messageQuotes.js

@@ -0,0 +1,17 @@
+export function quotedMessageIds(message) {
+    const row = message;
+    return [row.body?.content?.quote?.messageId, row.legacyDisplay?.quote?.messageId].filter((id) => typeof id === "string" && id.length > 0 && id.length <= 256);
+}
+export function redactMessageQuotes(messages, targets) {
+    const recalled = new Set(targets.filter(message => message.recalled || message.legacyDisplay?.recalled).map(message => message.id));
+    if (!recalled.size)
+        return messages;
+    return messages.map(message => {
+        const row = message, wire = row.body?.content?.quote, legacy = row.legacyDisplay?.quote;
+        const hideWire = typeof wire?.messageId === "string" && recalled.has(wire.messageId);
+        const hideLegacy = typeof legacy?.messageId === "string" && recalled.has(legacy.messageId);
+        if (!hideWire && !hideLegacy)
+            return message;
+        return { ...message, ...(hideWire ? { body: { ...row.body, content: { ...row.body?.content, quote: { ...wire, content: "[消息已撤回]" } } } } : {}), ...(hideLegacy ? { legacyDisplay: { ...row.legacyDisplay, quote: { ...legacy, content: "[消息已撤回]" } } } : {}) };
+    });
+}

package/lib/runtime/messageStore.d.ts

@@ -55,6 +55,12 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
         hasEarlier: boolean;
         coverage: MessageCoverage | undefined;
     }>;
+    /** Bounded identifier reads for SDK-owned view handoffs; no transport fallback. */
+    readSelected(thread: string, ids: readonly string[]): Promise<{
+        messages: T[];
+        hasEarlier: boolean;
+        coverage: MessageCoverage | undefined;
+    }>;
     /** Migration records never claim coverage or overwrite authoritative rows. */
     importLegacy(thread: string, messages: T[]): Promise<number>;
     /** Bounded fallback only; callers must report an incomplete window. */

package/lib/runtime/messageStore.js

@@ -1,4 +1,5 @@
 import { Dexie } from "dexie";
+import { quotedMessageIds, redactMessageQuotes } from "./messageQuotes.js";
 import { messageControls, controlKey, newerControl, applyMessageControls } from "./messageControls.js";
 export const messageScopeKey = (scope) => JSON.stringify([scope.appId, scope.accountId, scope.profileId, scope.teamId]);
 /** Normalized browser cache. Data and coverage advance together in each commit.
@@ -43,6 +44,20 @@ export class IndexedDbMessageStore {
         });
         return this.finishPage(thread, page);
     }
+    /** Bounded identifier reads for SDK-owned view handoffs; no transport fallback. */
+    async readSelected(thread, ids) {
+        if (ids.length > 100 || ids.some(id => !id || id.length > 256))
+            throw new Error("INVALID_MESSAGE_SELECTION");
+        const page = await this.db.transaction("r", this.rows, this.coverage, this.accessRows, this.controls, async () => {
+            const access = await this.scopeAccess();
+            const coverage = this.scopedCoverage(await this.coverage.get([this.key, thread]), access);
+            if (access.revoked || coverage?.revoked || (coverage?.scopeVersion ?? 0) !== access.version)
+                return { messages: [], hasEarlier: false, coverage: { ...coverage, complete: false, revoked: true, scopeVersion: access.version } };
+            const records = await this.rows.bulkGet([...new Set(ids)].map(id => [this.key, thread, id]));
+            return this.controlPage({ messages: records.flatMap(row => row ? [row.value] : []), hasEarlier: false, coverage });
+        });
+        return this.finishPage(thread, page);
+    }
     /** Migration records never claim coverage or overwrite authoritative rows. */
     async importLegacy(thread, messages) {
         if (messages.length > 128)
@@ -173,13 +188,19 @@ export class IndexedDbMessageStore {
         const events = page.messages.flatMap(message => messageControls(message, this.scope, this.key));
         const old = events.length ? await this.controls.bulkGet(events.map(controlKey)) : [];
         const pendingControls = events.filter((event, index) => newerControl(old[index], event) !== old[index]);
-        const facts = await this.controls.where("[scope+thread+target]").anyOf(page.messages.map(message => [this.key, message.threadId, message.id])).toArray();
+        const ids = new Set(page.messages.map(message => message.id));
+        const references = [...new Set(page.messages.flatMap(quotedMessageIds))].filter(id => !ids.has(id));
+        const thread = page.messages[0]?.threadId;
+        const targets = thread && references.length ? (await this.rows.bulkGet(references.map(id => [this.key, thread, id]))).flatMap(row => row ? [row.value] : []) : [];
+        const selected = [...page.messages, ...targets];
+        const facts = await this.controls.where("[scope+thread+target]").anyOf(selected.map(message => [this.key, message.threadId, message.id])).toArray();
         const latest = new Map();
         for (const event of [...facts, ...events]) {
             const key = JSON.stringify(controlKey(event));
             latest.set(key, newerControl(latest.get(key), event));
         }
-        return { ...page, messages: applyMessageControls(page.messages, [...latest.values()]), pendingControls };
+        const controlled = applyMessageControls(selected, [...latest.values()]);
+        return { ...page, messages: redactMessageQuotes(controlled.slice(0, page.messages.length), controlled), pendingControls };
     }
     async finishPage(thread, page) {
         const { pendingControls, ...result } = page;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.40",
+  "version": "0.12.0-next.41",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",
@@ -19,6 +19,11 @@
       "import": "./lib/index.js",
       "default": "./lib/index.js"
     },
+    "./bootstrap": {
+      "types": "./lib/runtime/messageLaunch.d.ts",
+      "import": "./lib/runtime/messageLaunch.js",
+      "default": "./lib/runtime/messageLaunch.js"
+    },
     "./runtime": {
       "types": "./lib/runtime/index.d.ts",
       "import": "./lib/runtime/index.js",