@pmate/chat-sdk 0.12.0-next.8 → 0.12.0-next.81

package/lib/runtime/outgoingContent.d.ts

@@ -0,0 +1,94 @@
+import { type ChatFile } from "../fileMetadata.js";
+import type { ChatMention } from "../mentions/model.js";
+import type { MessageScope } from "./messageStore.js";
+import type { SendMessageInput } from "./durableSender.js";
+export type ChatConversation = {
+    id: string;
+    kind: "dm" | "group";
+    targetId: string;
+    teamId?: string;
+    memberIds?: readonly string[];
+};
+export type MessageQuote = {
+    messageId?: string;
+    senderName: string;
+    content: string;
+};
+type ContentChoices = {
+    text: {
+        text: string;
+        mentions?: ChatMention[];
+        quote?: MessageQuote;
+    };
+    file: {
+        file: ChatFile;
+    };
+    image: {
+        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;
+        };
+    };
+    groupDissolve: {
+        groupDissolve: {
+            expectedRevision: 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

@@ -0,0 +1,118 @@
+import { parseChatFile } from "../fileMetadata.js";
+import { dmThreadId, groupThreadId } from "./thread.js";
+const contentKeys = ["text", "file", "image", "voice", "recall", "reaction", "invitation", "groupCreate", "groupUpdate", "groupDissolve"];
+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) {
+    const validMembers = [...new Set(memberIds)], members = validMembers.filter(id => id !== senderId), entries = [...(mentions ?? [])];
+    const pattern = /(?:^|[\s([{，。！？、：；])(@(?:all|所有人))(?=$|[\s,.;:!?，。！？、：；)\]}])/gu;
+    for (const match of text.matchAll(pattern)) {
+        const start = match.index + match[0].length - match[1].length;
+        if (!entries.some(entry => entry.start === start && entry.end === start + match[1].length))
+            entries.push({ id: ALL_MENTION_ID, name: match[1].slice(1), start, end: start + match[1].length });
+    }
+    const seen = new Set();
+    return entries.flatMap(entry => {
+        if (text.slice(entry.start, entry.end) !== `@${entry.name}`)
+            return [];
+        if (entry.id === ALL_MENTION_ID)
+            return ["all", "所有人"].includes(entry.name) ? members.map(id => ({ ...entry, id })) : [];
+        return validMembers.includes(entry.id) ? [entry] : [];
+    }).filter(entry => { const key = `${entry.id}:${entry.start}:${entry.end}`; if (seen.has(key))
+        return false; seen.add(key); return true; });
+}
+/** Build the existing wire protocol inside the owner, before durable acceptance. */
+export function outgoingContent(scope, thread, input) {
+    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 (input.groupDissolve) {
+        if (thread.kind !== "group" || !validMessageIdentifier(input.groupDissolve.expectedRevision))
+            throw new Error("INVALID_GROUP_DISSOLVE");
+        return { to: thread.targetId, body: { kind: "group", threadKind: "group", action: "groupDissolve", payload: { ...identity, groupId: thread.targetId, expectedRevision: input.groupDissolve.expectedRevision } } };
+    }
+    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.length > 256 || !recipients.every(validMessageIdentifier)))
+        throw new Error("MESSAGE_GROUP_MEMBERS_UNAVAILABLE");
+    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 } } } };
+    }
+    if (input.file) {
+        const file = parseChatFile(input.file);
+        if (!file)
+            throw new Error("INVALID_MESSAGE_FILE");
+        return { to: thread.targetId, ...(recipients ? { recipients } : {}), body: { kind: "message", threadKind: thread.kind, contentKind: "text", content: { ...base, text: `[文件] ${file.name}\n${file.url}`, file } } };
+    }
+    let content, contentKind = "text", voiceBlob;
+    if ("text" in input) {
+        if (typeof input.text !== "string")
+            throw new Error("INVALID_MESSAGE_TEXT");
+        const mentions = thread.kind === "group" ? expandGroupMentions(input.text, input.mentions, recipients, scope.profileId) : input.mentions;
+        content = { ...base, text: input.text, ...(input.quote ? { quote: input.quote } : {}), ...(mentions?.length ? { mentions } : {}) };
+    }
+    else if ("image" in input && input.image) {
+        if (typeof input.image.url !== "string" || !input.image.url)
+            throw new Error("INVALID_MESSAGE_IMAGE");
+        contentKind = "image";
+        content = { ...base, url: input.image.url, ...(input.image.name === undefined ? {} : { name: input.image.name }) };
+    }
+    else if ("voice" in input && input.voice) {
+        const voice = input.voice;
+        if (!Number.isFinite(voice.durationMs) || voice.durationMs <= 0 || !("blob" in voice ? voice.blob instanceof Blob : typeof voice.url === "string" && voice.url.length > 0))
+            throw new Error("INVALID_MESSAGE_VOICE");
+        voiceBlob = voice.blob;
+        content = { ...base, text: "[语音]", voice: { url: voiceBlob ? "" : voice.url, durationMs: voice.durationMs, ...(voice.transcript ? { transcript: voice.transcript } : {}) } };
+    }
+    else
+        throw new Error("INVALID_MESSAGE_CONTENT");
+    return { to: thread.targetId, body: { kind: "message", threadKind: thread.kind, contentKind, content }, ...(recipients ? { recipients } : {}), ...(voiceBlob ? { voiceBlob } : {}) };
+}

package/lib/runtime/readBatchJournal.d.ts

@@ -0,0 +1,35 @@
+import { Dexie } from "dexie";
+export type ReadMutation = {
+    table: "readingThreads" | "readingMessages" | "readingPositions";
+    key: string[];
+    value?: unknown;
+};
+type Plan = {
+    profileKey: string[];
+    header: unknown;
+    versions?: unknown;
+};
+/** Cross-document serialization; the persisted journal is the crash boundary. */
+export declare function lockReadOwner<T>(factory: IDBFactory, name: string, owner: string, run: () => Promise<T>, fallback?: (run: () => Promise<T>) => Promise<T>): Promise<T>;
+/** Stage the full plan first, roll forward bounded batches, publish cursor last. */
+export declare class ReadBatchJournal {
+    private db;
+    private closed;
+    private rows;
+    private knownOwners;
+    private leases;
+    private acquiring;
+    constructor(db: Dexie, closed: () => boolean);
+    lease<T>(owner: string, run: () => Promise<T>): Promise<T>;
+    releaseLeases(): Promise<void>;
+    checkLeases(renew?: boolean): Promise<void>;
+    private check;
+    private tables;
+    recover(owner: string): Promise<void>;
+    private cleanup;
+    private apply;
+    private validatePlan;
+    private finish;
+    commit(owner: string, operations: Iterable<ReadMutation>, plan: Plan): Promise<void>;
+}
+export {};

package/lib/runtime/readBatchJournal.js

@@ -0,0 +1,210 @@
+import { Dexie } from "dexie";
+const LIMIT = 124, BYTES = 1024 * 1024, LEASE_MS = 5_000;
+const size = (value) => JSON.stringify(value).length * 3;
+const localLocks = new WeakMap();
+/** Cross-document serialization; the persisted journal is the crash boundary. */
+export async function lockReadOwner(factory, name, owner, run, fallback) {
+    const key = JSON.stringify(["pmate-reading", name, owner]);
+    if (typeof navigator !== "undefined" && navigator.locks)
+        return navigator.locks.request(key, run);
+    if (typeof window !== "undefined") {
+        if (!fallback)
+            throw new Error("READ_STORAGE_LOCK_UNAVAILABLE");
+        return fallback(run);
+    }
+    let locks = localLocks.get(factory);
+    if (!locks) {
+        locks = new Map();
+        localLocks.set(factory, locks);
+    }
+    const previous = locks.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise(resolve => { release = resolve; });
+    locks.set(key, current);
+    await previous;
+    try {
+        return await run();
+    }
+    finally {
+        release();
+        if (locks.get(key) === current)
+            locks.delete(key);
+    }
+}
+/** Stage the full plan first, roll forward bounded batches, publish cursor last. */
+export class ReadBatchJournal {
+    db;
+    closed;
+    rows;
+    knownOwners = new Set();
+    leases = new Map();
+    acquiring = new Set();
+    constructor(db, closed) {
+        this.db = db;
+        this.closed = closed;
+        this.rows = db.table("readBatches");
+    }
+    async lease(owner, run) {
+        const token = crypto.randomUUID();
+        for (;;) {
+            this.check();
+            const attempt = (async () => {
+                const acquired = await this.db.transaction("rw", this.rows, async () => {
+                    const old = (await this.rows.get([owner, "lease"]))?.lease;
+                    if (old && old.expires > Date.now())
+                        return false;
+                    await this.rows.put({ owner, key: "lease", lease: { token, expires: Date.now() + LEASE_MS } });
+                    return true;
+                });
+                if (acquired)
+                    this.leases.set(owner, token);
+                return acquired;
+            })();
+            this.acquiring.add(attempt);
+            const acquired = await attempt.finally(() => this.acquiring.delete(attempt));
+            if (acquired)
+                break;
+            await new Promise(resolve => setTimeout(resolve, 25));
+        }
+        try {
+            const result = await run();
+            this.check();
+            await this.db.transaction("r", this.rows, () => this.checkLeases());
+            return result;
+        }
+        finally {
+            this.leases.delete(owner);
+            if (!this.closed())
+                await this.db.transaction("rw", this.rows, async () => { if ((await this.rows.get([owner, "lease"]))?.lease?.token === token)
+                    await this.rows.delete([owner, "lease"]); });
+        }
+    }
+    async releaseLeases() {
+        await Promise.allSettled([...this.acquiring]);
+        for (const [owner, token] of this.leases)
+            await this.db.transaction("rw", this.rows, async () => { if ((await this.rows.get([owner, "lease"]))?.lease?.token === token)
+                await this.rows.delete([owner, "lease"]); });
+    }
+    async checkLeases(renew = false) {
+        for (const [owner, token] of this.leases) {
+            if ((await this.rows.get([owner, "lease"]))?.lease?.token !== token)
+                throw new Error("READ_STORAGE_LOCK_LOST");
+            if (renew)
+                await this.rows.put({ owner, key: "lease", lease: { token, expires: Date.now() + LEASE_MS } });
+        }
+    }
+    check() { if (this.closed())
+        throw new Error("READ_STORAGE_CLOSED"); }
+    tables() { return [this.rows, ...["readingProfiles", "readingVersions", "readingThreads", "readingMessages", "readingPositions"].map(name => this.db.table(name))]; }
+    async recover(owner) {
+        this.check();
+        const active = (await this.rows.get([owner, "active"]))?.active;
+        if (!active) {
+            if (!this.knownOwners.has(owner)) {
+                await this.cleanup(owner);
+                this.knownOwners.add(owner);
+            }
+            return;
+        }
+        const plan = (await this.rows.get([owner, `${active.id}:plan`]))?.plan;
+        if (!plan || typeof active.id !== "string" || !Number.isSafeInteger(active.next) || !Number.isSafeInteger(active.total) || active.next < 0 || active.total < 1 || active.next > active.total)
+            throw new Error("READ_STORAGE_INCOMPLETE");
+        this.validatePlan(owner, plan);
+        while (active.next < active.total) {
+            this.check();
+            await this.db.transaction("rw", this.tables(), async () => {
+                await this.checkLeases();
+                const chunk = await this.rows.get([owner, `${active.id}:${active.next}`]);
+                if (!chunk?.operations || chunk.operations.length > LIMIT || chunk.operations.some(operation => !["readingThreads", "readingMessages", "readingPositions"].includes(operation.table) || operation.key[0] !== owner || operation.value !== undefined && operation.value.owner !== owner))
+                    throw new Error("READ_STORAGE_INCOMPLETE");
+                await this.apply(chunk.operations);
+                await this.rows.put({ owner, key: "active", active: { ...active, next: active.next + 1 } });
+                await this.checkLeases(true);
+            });
+            active.next++;
+            await new Promise(resolve => setTimeout(resolve, 0));
+        }
+        this.check();
+        await this.db.transaction("rw", this.tables(), async () => { await this.checkLeases(); await this.finish(plan); await this.rows.delete([owner, "active"]); await this.checkLeases(true); });
+        await this.cleanup(owner);
+        this.knownOwners.add(owner);
+    }
+    async cleanup(owner) {
+        for (;;) {
+            this.check();
+            const keys = await this.rows.where("owner").equals(owner).limit(LIMIT).primaryKeys();
+            const removable = keys.filter(key => key[1] !== "lease");
+            if (removable.length)
+                await this.db.transaction("rw", this.rows, async () => { await this.checkLeases(); await this.rows.bulkDelete(removable); await this.checkLeases(true); });
+            const count = keys.length;
+            if (count < LIMIT)
+                return;
+            await new Promise(resolve => setTimeout(resolve, 0));
+        }
+    }
+    async apply(operations) {
+        for (const name of ["readingThreads", "readingMessages", "readingPositions"]) {
+            const selected = operations.filter(operation => operation.table === name);
+            const writes = selected.filter(operation => operation.value !== undefined).map(operation => operation.value);
+            const deletes = selected.filter(operation => operation.value === undefined).map(operation => operation.key);
+            if (writes.length)
+                await this.db.table(name).bulkPut(writes);
+            if (deletes.length)
+                await this.db.table(name).bulkDelete(deletes);
+        }
+    }
+    validatePlan(owner, plan) {
+        const header = plan.header;
+        if (!Array.isArray(plan.profileKey) || JSON.stringify(plan.profileKey) !== owner || !header || header.schemaVersion !== 1 || header.appId !== plan.profileKey[0] || header.profileId !== plan.profileKey[1])
+            throw new Error("READ_IDENTITY_MISMATCH");
+    }
+    async finish(plan) {
+        if (plan.versions !== undefined)
+            await this.db.table("readingVersions").put(plan.versions, plan.profileKey);
+        await this.db.table("readingProfiles").put(plan.header, plan.profileKey);
+    }
+    async commit(owner, operations, plan) {
+        this.check();
+        this.validatePlan(owner, plan);
+        this.knownOwners.delete(owner);
+        await this.cleanup(owner);
+        if (size(plan) > BYTES)
+            throw new Error("READ_STORAGE_RECORD_TOO_LARGE");
+        const id = crypto.randomUUID(), iterator = operations[Symbol.iterator]();
+        let next = iterator.next(), total = 0;
+        while (!next.done) {
+            const batch = [];
+            let bytes = 512;
+            while (!next.done && batch.length < LIMIT) {
+                const weight = size(next.value);
+                if (weight > BYTES - 512)
+                    throw new Error("READ_STORAGE_RECORD_TOO_LARGE");
+                if (batch.length && bytes + weight > BYTES)
+                    break;
+                bytes += weight;
+                batch.push(next.value);
+                next = iterator.next();
+            }
+            if (total === 0 && next.done) {
+                await this.db.transaction("rw", this.tables(), async () => { await this.checkLeases(); await this.apply(batch); await this.finish(plan); await this.checkLeases(true); });
+                this.knownOwners.add(owner);
+                return;
+            }
+            this.check();
+            await this.db.transaction("rw", this.rows, async () => { await this.checkLeases(); await this.rows.put({ owner, key: `${id}:${total++}`, operations: batch }); await this.checkLeases(true); });
+            await new Promise(resolve => setTimeout(resolve, 0));
+        }
+        if (!total) {
+            await this.db.transaction("rw", this.tables(), async () => { await this.checkLeases(); await this.finish(plan); await this.checkLeases(true); });
+            this.knownOwners.add(owner);
+            return;
+        }
+        await this.db.transaction("rw", this.rows, async () => {
+            await this.checkLeases();
+            await this.rows.put({ owner, key: `${id}:plan`, plan });
+            await this.rows.put({ owner, key: "active", active: { id, next: 0, total } });
+            await this.checkLeases(true);
+        });
+        await this.recover(owner);
+    }
+}

package/lib/runtime/readCounts.d.ts

@@ -1,3 +1,5 @@
+import { type ResponseCacheAccess } from "./responseCache.js";
+import { type MessageScope } from "./messageStore.js";
 export type ReadCountsResult = {
     appId: string;
     threadId: string;
@@ -11,6 +13,8 @@ export type ReadCountsOptions = {
     clientInstanceId: string;
     hubHttpUrl: string;
     fetch?: typeof fetch;
+    scope?: MessageScope;
+    access?: ResponseCacheAccess;
     onChange: (value: ReadCountsResult) => void;
     onError?: (error: unknown) => void;
 };
@@ -25,13 +29,22 @@ export declare class ReadCountsClient {
     private generation;
     private retries;
     private closed;
+    private closing?;
     private revision;
     private running;
     private dirty;
     private subscribed;
     private subscriptionDenied;
     private subscriptionPending?;
+    private cache?;
+    private lastResult?;
+    private publish;
+    private revoked;
+    private accessVersion;
+    private requestedRevision;
+    private force;
     constructor(options: ReadCountsOptions);
+    private denyCache;
     private post;
     private subscription;
     private renew;
@@ -40,5 +53,6 @@ export declare class ReadCountsClient {
     reconnect(): void;
     private schedule;
     private refresh;
-    close(): void;
+    retireScope(version: number): Promise<void>;
+    close(): Promise<void>;
 }