@pmate/chat-sdk 0.12.0-next.7 → 0.12.0-next.71

package/lib/runtime/messageControls.d.ts

@@ -0,0 +1,19 @@
+import type { StoredMessage, MessageScope } from "./messageStore.js";
+export type MessageControl = {
+    scope: string;
+    thread: string;
+    target: string;
+    kind: "recall" | "reaction";
+    actor: string;
+    emoji: string;
+    id: string;
+    timestamp: number;
+    revision: number;
+    active: boolean;
+};
+export type ControlKey = [string, string, string, string, string, string];
+export declare const controlKey: (event: MessageControl) => ControlKey;
+export declare function newerControl(old: MessageControl | undefined, next: MessageControl): MessageControl;
+/** Body-free proofs retained independently of the visible history window. */
+export declare function messageControls(message: StoredMessage, scope: MessageScope, key: string): MessageControl[];
+export declare function applyMessageControls<T extends StoredMessage>(messages: T[], controls: readonly MessageControl[]): T[];

package/lib/runtime/messageControls.js

@@ -0,0 +1,44 @@
+export const controlKey = (event) => [event.scope, event.thread, event.target, event.kind, event.actor, event.emoji];
+export function newerControl(old, next) {
+    return !old || next.revision > old.revision || next.revision === old.revision && (next.timestamp > old.timestamp || next.timestamp === old.timestamp && next.id > old.id) ? next : old;
+}
+const identifier = (value) => typeof value === "string" && value.length > 0 && value.length <= 256;
+/** Body-free proofs retained independently of the visible history window. */
+export function messageControls(message, scope, key) {
+    const row = message;
+    if (row.appId !== undefined && row.appId !== scope.appId || row.teamId !== undefined && row.teamId !== scope.teamId || !identifier(row.from))
+        return [];
+    const apps = row.body;
+    const app = apps?.content?.appId ?? apps?.payload?.appId;
+    if (app !== undefined && app !== scope.appId)
+        return [];
+    if (row.recalled || row.legacyDisplay?.recalled)
+        return [{ scope: key, thread: message.threadId, target: message.id, kind: "recall", actor: row.from, emoji: "", id: message.id, timestamp: message.timestamp, revision: 0, active: true }];
+    const body = row.body;
+    const content = body?.kind === "message" && body.content?.appId === scope.appId ? body.content : undefined;
+    const target = body?.kind === "recall" && row.appId === scope.appId ? body.targetMessageId : content?.recall?.messageId;
+    const base = { scope: key, thread: message.threadId, actor: row.from, id: message.id, timestamp: message.timestamp };
+    if (identifier(target))
+        return [{ ...base, target, kind: "recall", emoji: "", revision: 0, active: true }];
+    const reaction = content?.reaction;
+    if (body?.contentKind === "text" && reaction?.version === 1 && identifier(reaction.messageId) && identifier(reaction.emojiId) && Number.isSafeInteger(reaction.revision) && (reaction.revision ?? 0) >= 1 && typeof reaction.active === "boolean")
+        return [{ ...base, target: reaction.messageId, kind: "reaction", emoji: reaction.emojiId, revision: reaction.revision, active: reaction.active }];
+    return [];
+}
+export function applyMessageControls(messages, controls) {
+    const grouped = new Map();
+    for (const event of controls) {
+        const list = grouped.get(event.target) ?? [];
+        list.push(event);
+        grouped.set(event.target, list);
+    }
+    return messages.map(message => {
+        const facts = grouped.get(message.id);
+        if (!facts?.length)
+            return message;
+        const row = message;
+        const recalled = message.recalled || facts.some(event => event.kind === "recall" && event.actor === row.from);
+        const reactionEvents = facts.filter(event => event.kind === "reaction").map(event => ({ id: event.id, messageId: event.target, threadId: event.thread, from: event.actor, emojiId: event.emoji, active: event.active, revision: event.revision, timestamp: event.timestamp }));
+        return { ...message, ...(recalled ? { recalled: true } : {}), ...(reactionEvents.length ? { reactionEvents: [...(row.reactionEvents ?? []), ...reactionEvents] } : {}) };
+    });
+}

package/lib/runtime/messageLaunch.d.ts

@@ -0,0 +1,44 @@
+import { type ChatMessage } from "../messageView.js";
+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>;
+    messages: readonly ChatMessage[]; /** @deprecated Advanced compatibility projection. */
+    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,137 @@
+import { createMessagePresenter } from "../messageView.js";
+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 present = createMessagePresenter();
+    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);
+        const normalized = timeline.map(present), visibleImages = new Set(normalized.flatMap(message => message.image ? [message.image.url] : []));
+        const images = Object.fromEntries(Object.entries(ticket.images).filter(([url]) => visibleImages.has(url)));
+        onChange(timeline.length ? { openId, threadId, metadata: ticket.metadata, images, messages: normalized, 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") {
+                if (ticket && Number.isSafeInteger(event.data.version) && event.data.version > ticket.scopeVersion)
+                    hide();
+                return;
+            }
+            if (event.data?.type === "revoked" && event.data.thread === threadId) {
+                if (ticket && Number.isSafeInteger(event.data.version) && (event.data.scopeVersion ?? 0) === ticket.scopeVersion && event.data.version > ticket.resetVersion)
+                    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/messageReaders.d.ts

@@ -1,3 +1,5 @@
+import { type ResponseCacheAccess } from "./responseCache.js";
+import { type MessageScope } from "./messageStore.js";
 export type MessageReadersPage = {
     appId: string;
     threadId: string;
@@ -21,6 +23,9 @@ export type MessageReadersOptions = {
     token: string;
     hubHttpUrl: string;
     fetch?: typeof fetch;
+    scope?: MessageScope;
+    access?: ResponseCacheAccess;
+    onError?: (error: unknown) => void;
 };
 export declare class MessageReadersError extends Error {
     readonly status: number;
@@ -32,8 +37,14 @@ export declare class MessageReadersClient {
     private options;
     private pending;
     private lifetime;
+    private cache?;
+    private revoked;
+    private generation;
     constructor(options: MessageReadersOptions);
     getReaders(query: MessageReadersQuery, signal?: AbortSignal): Promise<MessageReadersPage>;
+    private cachedRequest;
     private request;
-    close(): void;
+    withdraw(): void;
+    retireScope(version: number): Promise<void>;
+    close(): Promise<void>;
 }

package/lib/runtime/messageReaders.js

@@ -1,3 +1,6 @@
+import { isOffline } from "./connectivity.js";
+import { IndexedDbResponseCache, isResponseCacheAuthorityError, assertResponseCacheAccess } from "./responseCache.js";
+import { messageScopeKey } from "./messageStore.js";
 export class MessageReadersError extends Error {
     status;
     forbidden;
@@ -12,7 +15,17 @@ export class MessageReadersClient {
     options;
     pending = new Map();
     lifetime = new AbortController();
-    constructor(options) { this.options = { ...options }; }
+    cache;
+    revoked = false;
+    generation = 0;
+    constructor(options) {
+        this.options = { ...options };
+        if (options.scope) {
+            if (options.scope.appId !== options.appId || options.scope.profileId !== options.profileId)
+                throw new Error("MESSAGE_READERS_SCOPE_MISMATCH");
+            this.cache = new IndexedDbResponseCache(messageScopeKey(options.scope), { access: options.access });
+        }
+    }
     getReaders(query, signal) {
         if (this.lifetime.signal.aborted)
             return Promise.reject(new Error("MESSAGE_READERS_CLOSED"));
@@ -24,7 +37,7 @@ export class MessageReadersClient {
         const key = JSON.stringify([input.threadId, input.messageId, input.afterProfileId, input.revision, input.limit]);
         let task = this.pending.get(key);
         if (!task) {
-            task = this.request(input).finally(() => { if (this.pending.get(key) === task)
+            task = this.cachedRequest(input, key).finally(() => { if (this.pending.get(key) === task)
                 this.pending.delete(key); });
             this.pending.set(key, task);
         }
@@ -37,7 +50,54 @@ export class MessageReadersClient {
             task.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
         });
     }
+    async cachedRequest(input, key) {
+        // Keep only the standard SDK window. Arbitrary page sizes must not multiply
+        // durable cache entries. Revision is part of the key, so changed counts do
+        // not reuse a page from a previous membership/read projection.
+        const cache = input.limit === 50 ? this.cache : undefined;
+        if (!cache)
+            return this.request(input);
+        const stored = await cache.read(key).catch(error => { if (isResponseCacheAuthorityError(error))
+            throw error; this.options.onError?.(error); return undefined; });
+        if (this.lifetime.signal.aborted)
+            throw new Error("MESSAGE_READERS_CLOSED");
+        const generation = this.generation;
+        const cached = this.revoked ? undefined : stored?.cached;
+        if (cached && (Date.now() - cached.time < 5000 || (typeof navigator !== "undefined" && navigator.onLine === false)))
+            return structuredClone(cached.value);
+        let value;
+        try {
+            value = await this.request(input);
+        }
+        catch (error) {
+            if (error instanceof MessageReadersError && error.forbidden) {
+                this.revoked = true;
+                this.generation++;
+                await this.cache?.invalidate().catch(failure => this.options.onError?.(failure));
+                throw error;
+            }
+            if (cached && !this.revoked && generation === this.generation && !this.lifetime.signal.aborted && (error instanceof TypeError || (error instanceof MessageReadersError && error.status >= 500)))
+                return structuredClone(cached.value);
+            throw error;
+        }
+        if (generation !== this.generation)
+            throw new Error("MESSAGE_READERS_INVALIDATED");
+        this.revoked = false;
+        if (value.resetRequired)
+            await cache?.invalidate().catch(error => this.options.onError?.(error));
+        else if (stored)
+            await cache?.write(key, value, stored.epoch).catch(error => { if (isResponseCacheAuthorityError(error))
+                throw error; this.options.onError?.(error); });
+        if (this.lifetime.signal.aborted)
+            throw new Error("MESSAGE_READERS_CLOSED");
+        return value;
+    }
     async request(input) {
+        const scopeVersion = this.options.access ? await assertResponseCacheAccess(this.options.access) : undefined;
+        if (this.lifetime.signal.aborted)
+            throw new Error("MESSAGE_READERS_CLOSED");
+        if (isOffline())
+            throw new MessageReadersError(0, "MESSAGE_READERS_OFFLINE_UNAVAILABLE");
         const { token, fetch: fetcher, hubHttpUrl, appId, profileId } = this.options;
         const controller = new AbortController();
         const cancel = () => controller.abort(this.lifetime.signal.reason);
@@ -60,6 +120,8 @@ export class MessageReadersClient {
                 throw new Error("INVALID_MESSAGE_READERS_RESPONSE");
             if (this.lifetime.signal.aborted)
                 throw new Error("MESSAGE_READERS_CLOSED");
+            if (this.options.access)
+                await assertResponseCacheAccess(this.options.access, scopeVersion);
             return data;
         }
         finally {
@@ -67,5 +129,7 @@ export class MessageReadersClient {
             this.lifetime.signal.removeEventListener("abort", cancel);
         }
     }
-    close() { this.lifetime.abort(); this.pending.clear(); }
+    withdraw() { this.lifetime.abort(); this.pending.clear(); }
+    retireScope(version) { return this.cache?.retire(version) ?? Promise.resolve(); }
+    close() { this.lifetime.abort(); this.pending.clear(); return this.cache?.close().catch(error => this.options.onError?.(error)) ?? Promise.resolve(); }
 }

package/lib/runtime/messageStore.d.ts

@@ -18,6 +18,12 @@ export type MessageCoverage = {
     syncedAt?: number;
     resetVersion?: number;
     revoked?: boolean;
+    scopeVersion?: number;
+};
+export type MessageScopeAccess = {
+    scope: string;
+    version: number;
+    revoked: boolean;
 };
 type CoverageRow = MessageCoverage & {
     scope: string;
@@ -27,10 +33,14 @@ export declare const messageScopeKey: (scope: MessageScope) => string;
 /** Normalized browser cache. Data and coverage advance together in each commit.
  * Merge runs inside the write transaction against the latest cross-tab state. */
 export declare class IndexedDbMessageStore<T extends StoredMessage> {
+    private scope;
     private merge;
     private db;
     private rows;
+    private legacy;
     private coverage;
+    private accessRows;
+    private controls;
     private key;
     constructor(scope: MessageScope, merge: (previous: T | undefined, incoming: T) => T, options?: {
         indexedDB?: IDBFactory;
@@ -43,15 +53,43 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
     }): Promise<{
         messages: T[];
         hasEarlier: boolean;
-        coverage: CoverageRow | undefined;
+        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. */
+    readFallback(thread: string, limit?: number, before?: {
+        timestamp: number;
+        id: string;
+    }): Promise<{
+        messages: T[];
+        hasEarlier: boolean;
+        coverage: MessageCoverage | undefined;
     }>;
     commit(thread: string, messages: T[], coverage?: MessageCoverage, guard?: {
         version: number;
         authoritative?: boolean;
+        scopeVersion?: number;
     }): Promise<number>;
+    private rememberControls;
+    private controlPage;
+    private finishPage;
     windows(): Promise<CoverageRow[]>;
+    scopeAccess(): Promise<MessageScopeAccess>;
+    /** Only fresh, server-confirmed authorization may lift this durable tombstone. */
+    authorizeScope(expectedVersion: number): Promise<void>;
+    private scopedCoverage;
+    private clearScopeRows;
+    /** Persist the denial first; failed cleanup must never make cached rows readable. */
+    revokeScope(expectedVersion?: number): Promise<number>;
     /** A durable epoch prevents another tab's pre-reset request from restoring rows. */
-    resetThread(thread: string, revoked?: boolean): Promise<number>;
+    resetThread(thread: string, revoked?: boolean, scopeVersion?: number): Promise<number>;
     removeThread(thread: string): Promise<void>;
     clear(): Promise<void>;
     close(): void;