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

package/lib/runtime/messageTimeline.js

@@ -0,0 +1,120 @@
+import { isReadingControl } from "./readingContent.js";
+function content(message, appId) {
+    const body = message.body;
+    return body?.kind === "message" && body.content?.appId === appId ? body : undefined;
+}
+function nativeRecall(message, appId) {
+    const body = message.body;
+    return message.appId === appId && body?.kind === "recall" && typeof body.targetMessageId === "string" && body.targetMessageId.length > 0 && body.targetMessageId.length <= 256 ? body.targetMessageId : undefined;
+}
+function isControl(message, appId) { return isReadingControl(message.body, appId) || nativeRecall(message, appId) !== undefined; }
+function validReaction(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const event = value;
+    return [event.id, event.messageId, event.from, event.emojiId].every(field => typeof field === "string" && field.length > 0 && field.length <= 256) && typeof event.active === "boolean" && Number.isSafeInteger(event.revision) && event.revision >= 0 && Number.isFinite(event.timestamp);
+}
+/** Derives one display stream without copying bodies or creating another cache.
+ * Outgoing rows retain their wire identity; indexed rows take precedence. */
+export function projectMessageTimeline(input) {
+    const scoped = (message) => {
+        const value = message, body = value.body;
+        const app = body?.content?.appId ?? body?.payload?.appId;
+        return message.threadId === input.threadId && (value.appId === undefined || value.appId === input.appId) && (app === undefined || app === input.appId);
+    };
+    const tombstones = new Set(input.messages.filter(message => scoped(message) && (message.recalled || message.legacyDisplay?.recalled)).map(message => message.id));
+    const records = new Map();
+    for (const pending of input.outgoing) {
+        if (pending.threadId !== input.threadId || pending.confirmed)
+            continue;
+        const message = input.decode(pending.message);
+        if (message && scoped(message))
+            records.set(message.id, { message, status: pending.status });
+    }
+    for (const message of input.messages)
+        if (scoped(message)) {
+            const legacy = message.legacyDisplay;
+            if (legacy && records.has(message.id))
+                continue;
+            const legacyStatus = legacy?.status;
+            const status = legacyStatus === "failed" || legacyStatus === "sending" || legacyStatus === "read" ? legacyStatus : "sent";
+            records.set(message.id, { message, status });
+        }
+    const recalled = new Map(), reactions = new Map();
+    const addReaction = (event) => {
+        const key = JSON.stringify([event.messageId, event.from, event.emojiId]), old = reactions.get(key);
+        if (!old || event.revision > old.revision || event.revision === old.revision && (event.timestamp > old.timestamp || event.timestamp === old.timestamp && event.id > old.id))
+            reactions.set(key, event);
+    };
+    for (const { message, status } of records.values()) {
+        if (status === "failed" && isControl(message, input.appId))
+            continue;
+        const envelope = message, body = content(envelope, input.appId), target = nativeRecall(envelope, input.appId) ?? body?.content?.recall?.messageId;
+        if (typeof target === "string" && target.length > 0 && target.length <= 256 && envelope.from) {
+            if (!recalled.has(target))
+                recalled.set(target, new Set());
+            recalled.get(target).add(envelope.from);
+        }
+        const reaction = body?.content?.reaction;
+        if (body?.contentKind === "text" && reaction?.version === 1 && typeof reaction.messageId === "string" && typeof reaction.emojiId === "string" && typeof reaction.active === "boolean" && typeof reaction.revision === "number" && reaction.revision >= 1 && envelope.from) {
+            const event = { id: message.id, messageId: reaction.messageId, from: envelope.from, emojiId: reaction.emojiId, active: reaction.active, revision: reaction.revision, timestamp: message.timestamp };
+            if (validReaction(event))
+                addReaction(event);
+        }
+        const events = envelope.reactionEvents ?? envelope.legacyDisplay?.reactionEvents;
+        if (Array.isArray(events))
+            for (const event of events)
+                if (validReaction(event) && event.messageId === message.id && (event.threadId === undefined || event.threadId === input.threadId))
+                    addReaction(event);
+        // Old display-only imports may have aggregates but no event IDs. Treat them
+        // as revision-zero baselines; any durable control supersedes them.
+        const baseline = envelope.legacyDisplay?.reactions;
+        if (Array.isArray(baseline))
+            for (const value of baseline) {
+                if (typeof value?.emojiId !== "string" || !Array.isArray(value.userIds))
+                    continue;
+                for (const from of value.userIds) {
+                    const event = { id: `legacy:${message.id}`, messageId: message.id, from, emojiId: value.emojiId, active: true, revision: 0, timestamp: 0 };
+                    if (validReaction(event))
+                        addReaction(event);
+                }
+            }
+    }
+    const groupedEvents = new Map();
+    for (const event of reactions.values()) {
+        const values = groupedEvents.get(event.messageId) ?? [];
+        values.push({ ...event, threadId: input.threadId });
+        groupedEvents.set(event.messageId, values);
+    }
+    for (const values of groupedEvents.values())
+        values.sort((a, b) => a.from < b.from ? -1 : a.from > b.from ? 1 : a.emojiId < b.emojiId ? -1 : a.emojiId > b.emojiId ? 1 : 0);
+    const grouped = new Map();
+    for (const event of reactions.values())
+        if (event.active) {
+            if (!grouped.has(event.messageId))
+                grouped.set(event.messageId, new Map());
+            const emojis = grouped.get(event.messageId);
+            if (!emojis.has(event.emojiId))
+                emojis.set(event.emojiId, new Set());
+            emojis.get(event.emojiId).add(event.from);
+        }
+    const previous = new Map(input.previous?.map(item => [item.id, item]) ?? []);
+    const result = [];
+    for (const { message, status } of records.values()) {
+        const envelope = message;
+        if (isControl(envelope, input.appId))
+            continue;
+        const mine = envelope.from === input.profileId, reading = input.reading[message.id];
+        const withdrawn = Boolean(tombstones.has(message.id) || message.recalled || envelope.legacyDisplay?.recalled || envelope.from && recalled.get(message.id)?.has(envelope.from));
+        const candidate = input.candidates?.get(message.id);
+        const item = { id: message.id, threadId: message.threadId, timestamp: message.timestamp, from: envelope.from, mine, status: !mine && reading ? (reading.read ? "read" : status === "read" ? "sent" : status) : status, recalled: withdrawn, ...(candidate ? { unread: !mine && !withdrawn && (reading ? !reading.read : candidate.unread), attentionEligible: candidate.attentionEligible } : {}),
+            message: withdrawn ? undefined : message, reading, reactionEvents: withdrawn ? [] : groupedEvents.get(message.id) ?? [], reactions: withdrawn ? [] : [...(grouped.get(message.id) ?? [])].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([emojiId, users]) => { const userIds = [...users].sort(); return { emojiId, userIds, mine: userIds.includes(input.profileId) }; }) };
+        const old = previous.get(item.id);
+        const sameReading = old?.reading === item.reading || old?.reading?.seq === item.reading?.seq && old?.reading?.read === item.reading?.read && old?.reading?.readPolicy === item.reading?.readPolicy;
+        const sameReactions = old?.reactions.length === item.reactions.length && old.reactions.every((reaction, index) => { const next = item.reactions[index]; return reaction.emojiId === next.emojiId && reaction.mine === next.mine && reaction.userIds.length === next.userIds.length && reaction.userIds.every((user, i) => user === next.userIds[i]); });
+        const sameEvents = old?.reactionEvents.length === item.reactionEvents.length && old.reactionEvents.every((event, index) => { const next = item.reactionEvents[index]; return event.id === next.id && event.from === next.from && event.emojiId === next.emojiId && event.active === next.active && event.revision === next.revision && event.timestamp === next.timestamp && event.threadId === next.threadId && event.messageId === next.messageId; });
+        result.push(old && sameEvents && old.message === item.message && old.timestamp === item.timestamp && old.from === item.from && old.mine === item.mine && old.status === item.status && old.recalled === item.recalled && old.unread === item.unread && old.attentionEligible === item.attentionEligible && sameReading && sameReactions ? old : item);
+    }
+    result.sort((a, b) => a.timestamp - b.timestamp || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return input.previous?.length === result.length && result.every((item, index) => item === input.previous[index]) ? input.previous : result;
+}

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>;
 }

package/lib/runtime/readCounts.js

@@ -1,3 +1,6 @@
+import { isOffline, isOfflineNetworkFailure } from "./connectivity.js";
+import { IndexedDbResponseCache, isResponseCacheAuthorityError, assertResponseCacheAccess } from "./responseCache.js";
+import { messageScopeKey } from "./messageStore.js";
 let subscriptionSequence = 0;
 function nextSubscriptionSequence() { subscriptionSequence = Math.max(Date.now() * 1000, subscriptionSequence + 1); return subscriptionSequence; }
 /** One active conversation; fixed event window, bounded batches, no count polling. */
@@ -11,29 +14,58 @@ export class ReadCountsClient {
     generation = 0;
     retries = 0;
     closed = false;
+    closing;
     revision = -1;
     running = false;
     dirty = false;
     subscribed = false;
     subscriptionDenied = false;
     subscriptionPending;
+    cache;
+    lastResult;
+    publish(value) {
+        if (JSON.stringify(value) === JSON.stringify(this.lastResult))
+            return;
+        this.lastResult = value;
+        this.options.onChange(value);
+    }
+    revoked = false;
+    accessVersion = 0;
+    requestedRevision = -1;
+    force = false;
     constructor(options) {
         this.options = options;
+        if (options.scope) {
+            if (options.scope.appId !== options.appId || options.scope.profileId !== options.profileId)
+                throw new Error("READ_COUNTS_SCOPE_MISMATCH");
+            this.cache = new IndexedDbResponseCache(messageScopeKey(options.scope), { access: options.access });
+        }
+    }
+    denyCache() {
+        this.revoked = true;
+        this.accessVersion++;
+        this.lastResult = undefined;
+        void this.cache?.invalidate().catch(error => this.options.onError?.(error));
     }
     async post(path, body, signal) {
+        const scopeVersion = this.options.access ? await assertResponseCacheAccess(this.options.access) : undefined;
         const response = await (this.options.fetch ?? fetch)(`${this.options.hubHttpUrl.replace(/\/$/, "")}${path}`, { method: "POST", headers: { authorization: `Bearer ${this.options.token}`, "content-type": "application/json" }, body: JSON.stringify(body), signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(8000)]) : AbortSignal.timeout(8000), redirect: "error" });
         if (!response.ok)
             throw new Error(`READ_COUNTS_HTTP_${response.status}`);
         const envelope = await response.json();
         if (envelope.success !== true)
             throw new Error("INVALID_READ_COUNTS_RESPONSE");
+        if (this.options.access)
+            await assertResponseCacheAccess(this.options.access, scopeVersion);
         return envelope.data;
     }
     subscription(threadId, release) {
+        if (release && isOffline())
+            return Promise.resolve();
         return this.post("/api/social/reading/subscription", { appId: this.options.appId, profileId: this.options.profileId, threadId, clientInstanceId: this.options.clientInstanceId, sequence: nextSubscriptionSequence(), release });
     }
     renew() {
-        if (!this.thread || this.closed || this.subscriptionDenied)
+        if (!this.thread || this.closed || this.subscriptionDenied || (typeof navigator !== "undefined" && navigator.onLine === false))
             return;
         const threadId = this.thread, generation = this.generation;
         if (this.subscriptionPending?.generation === generation)
@@ -48,18 +80,29 @@ export class ReadCountsClient {
                 this.heartbeat = setInterval(() => { if (!this.closed && this.thread === threadId)
                     this.renew(); }, 20_000);
             // Recover changes that occurred before a receiver/subscription became ready.
-            if (recovered && this.revision >= 0)
+            if (recovered) {
+                // A fresh cache predates the new lease and cannot cover its delivery gap.
+                this.force = true;
                 this.schedule(0);
+            }
         }).catch(error => {
             if (this.closed || generation !== this.generation)
                 return;
             this.subscribed = false;
             if (/READ_COUNTS_HTTP_(401|403)/.test(String(error))) {
                 this.subscriptionDenied = true;
+                this.denyCache();
                 clearInterval(this.heartbeat);
                 this.heartbeat = undefined;
             }
-            this.options.onError?.(error);
+            if (isResponseCacheAuthorityError(error)) {
+                this.lastResult = undefined;
+                this.subscriptionDenied = true;
+                clearInterval(this.heartbeat);
+                this.heartbeat = undefined;
+            }
+            if (!isOfflineNetworkFailure(error))
+                this.options.onError?.(error);
         }).finally(() => { if (this.subscriptionPending === pending)
             this.subscriptionPending = undefined; });
         this.subscriptionPending = pending;
@@ -83,9 +126,12 @@ export class ReadCountsClient {
         clearTimeout(this.timer);
         clearInterval(this.heartbeat);
         this.timer = undefined;
+        this.lastResult = undefined;
         this.thread = threadId;
         this.ids = ids;
         this.revision = -1;
+        this.requestedRevision = -1;
+        this.force = false;
         this.dirty = false;
         this.retries = 0;
         this.subscribed = false;
@@ -104,11 +150,13 @@ export class ReadCountsClient {
             throw new Error("INVALID_READ_COUNTS_EVENT");
         if (threadId !== this.thread || revision <= this.revision || this.closed)
             return;
+        this.requestedRevision = Math.max(this.requestedRevision, revision);
         this.schedule(3000);
     }
     reconnect() {
         if (!this.thread || this.closed)
             return;
+        this.force = true;
         this.subscribed = false;
         this.subscriptionDenied = false;
         this.renew();
@@ -137,22 +185,60 @@ export class ReadCountsClient {
         let retryDelay;
         const controller = new AbortController();
         this.controller = controller;
+        const accessVersion = this.accessVersion, force = this.force;
+        this.force = false;
+        const key = JSON.stringify(["counts", threadId, [...ids].sort()]);
         try {
+            const stored = this.cache ? await this.cache.read(key).catch(error => { if (isResponseCacheAuthorityError(error))
+                throw error; this.options.onError?.(error); return undefined; }) : undefined;
+            if (generation !== this.generation || this.closed || accessVersion !== this.accessVersion)
+                return;
+            const cached = this.revoked || (stored?.cached && stored.cached.value.revision < this.revision) ? undefined : stored?.cached;
+            if (cached) {
+                this.revision = cached.value.revision;
+                this.publish(cached.value);
+                const offline = typeof navigator !== "undefined" && navigator.onLine === false;
+                if (offline || (!force && this.requestedRevision <= this.revision && Date.now() - cached.time < 5000))
+                    return;
+            }
+            if (isOffline())
+                return;
             const value = await this.post("/api/social/reading/counts", { appId: this.options.appId, profileId: this.options.profileId, threadId, messageIds: ids }, controller.signal);
-            if (generation !== this.generation || this.closed)
+            if (generation !== this.generation || this.closed || accessVersion !== this.accessVersion)
                 return;
             if (value?.appId !== this.options.appId || value.threadId !== threadId || !Number.isSafeInteger(value.revision) || value.revision < 0 || !value.counts || typeof value.counts !== "object" || ids.some(id => !Number.isSafeInteger(value.counts[id]) || value.counts[id] < 0) || Object.keys(value.counts).some(id => !ids.includes(id)))
                 throw new Error("INVALID_READ_COUNTS_RESULT");
+            if (value.revision < this.revision)
+                return;
             this.retries = 0;
+            this.revoked = false;
+            if (stored)
+                await this.cache?.write(key, value, stored.epoch).catch(error => { if (isResponseCacheAuthorityError(error))
+                    throw error; this.options.onError?.(error); });
+            if (generation !== this.generation || this.closed || accessVersion !== this.accessVersion)
+                return;
             this.revision = value.revision;
-            this.options.onChange(value);
+            this.publish(value);
             if (!this.subscribed)
                 this.renew();
         }
         catch (error) {
+            if (isOfflineNetworkFailure(error)) {
+                this.dirty = false;
+                return;
+            }
             if (!controller.signal.aborted && generation === this.generation && !this.closed) {
+                if (/READ_COUNTS_HTTP_(401|403)/.test(String(error)))
+                    this.denyCache();
+                if (isResponseCacheAuthorityError(error)) {
+                    this.lastResult = undefined;
+                    this.subscriptionDenied = true;
+                    this.dirty = false;
+                    clearInterval(this.heartbeat);
+                    this.heartbeat = undefined;
+                }
                 this.options.onError?.(error);
-                if (!/READ_COUNTS_HTTP_4\d\d|INVALID_READ_COUNTS/.test(String(error)) && this.retries < 3) {
+                if (!isResponseCacheAuthorityError(error) && !/READ_COUNTS_HTTP_4\d\d|INVALID_READ_COUNTS/.test(String(error)) && this.retries < 3) {
                     retryDelay = 1000 * 2 ** this.retries++;
                     this.dirty = true;
                 }
@@ -166,9 +252,10 @@ export class ReadCountsClient {
             }
         }
     }
+    retireScope(version) { return this.cache?.retire(version) ?? Promise.resolve(); }
     close() {
-        if (this.closed)
-            return;
+        if (this.closing)
+            return this.closing;
         const old = this.thread;
         this.closed = true;
         this.generation++;
@@ -178,5 +265,6 @@ export class ReadCountsClient {
         if (old)
             void this.subscription(old, true).catch(() => { });
         this.thread = undefined;
+        return this.closing = this.cache?.close().catch(error => this.options.onError?.(error)) ?? Promise.resolve();
     }
 }

package/lib/runtime/readIndex.d.ts

@@ -7,9 +7,16 @@ export type IndexedReadMessage = {
     mentions: string[];
     readPolicy: "visible" | "explicit";
     recalled: boolean;
-    /** Cached payload is retained so an offline reload can render the message. */
+    /** Legacy standalone readers may retain payloads; unified sessions use the message store. */
     payload: unknown;
+    /** Body-free control classification retained by metadata-only reading indexes. */
+    readingControl?: boolean;
 };
+/** Retain read semantics without a second durable copy of message bodies. */
+export declare function readingMetadata<T extends {
+    appId: string;
+    threads: IndexedReadThread[];
+}>(state: T): T;
 export type ReadingOperation = {
     operationId: string;
     threadId: string;
@@ -72,32 +79,63 @@ export declare function coalesceReadOperations(current: ReadIndexState): (Readin
     operationIds: string[];
 })[];
 /** Counts are over the indexed message coverage, not an estimate of missing history. */
-export declare function unreadInThread(state: ReadIndexState, threadId: string): {
+export declare function unreadInThread(state: ReadIndexState, threadId: string, hidden?: ReadonlyMap<string, ReadonlySet<string>>): {
     unreadMessageCount: number;
     unreadMentionCount: number;
     badgeCount: number;
 };
+export type ReadIndexVersions = Readonly<Record<string, number>>;
+export type ReadIndexTransform = (current: ReadIndexState, versions?: ReadIndexVersions) => ReadIndexState;
+export declare function assertReadIndexVersions(expected: ReadIndexVersions, current?: ReadIndexVersions, teamId?: string): void;
+/** Remove only the withdrawn team's original sources, logical conversations and
+ * queued observations. Other teams' pending operations must survive. */
+export declare function removeReadTeam(state: ReadIndexState, teamId: string, knownThreadIds?: readonly string[]): ReadIndexState;
 export interface ReadIndexPersistence {
     load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
+    loadVersioned?(appId: string, profileId: string): Promise<{
+        state: ReadIndexState | undefined;
+        versions: ReadIndexVersions;
+    }>;
+    loadVersions?(appId: string, profileId: string): Promise<ReadIndexVersions>;
+    invalidateTeam?(appId: string, profileId: string, teamId: string, version: number, knownThreadIds?: readonly string[]): Promise<ReadIndexState>;
     /** Transform and persist atomically; UI publishes only the committed result. */
-    update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
+    update(appId: string, profileId: string, transform: ReadIndexTransform): Promise<ReadIndexState>;
 }
 /** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export declare class IndexedDbReadIndex implements ReadIndexPersistence {
     private storageScope?;
+    private migrateLegacy;
+    private metadataOnly;
     private database;
     private profiles;
+    private threadRows;
+    private messageRows;
+    private positionRows;
+    private normalizedStates;
+    private versions;
     private closed;
-    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined);
+    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined, migrateLegacy?: boolean, metadataOnly?: boolean);
     private transaction;
     private key;
+    private hydrate;
+    private loadCurrent;
+    private loadStored;
+    /** Message bodies are immutable for local read observations: keep them out of
+     * profile/cursor writes, and update only changed normalized rows on sync. */
+    private persist;
     load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
-    update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
+    loadVersioned(appId: string, profileId: string): Promise<{
+        state: ReadIndexState | undefined;
+        versions: Record<string, number>;
+    }>;
+    loadVersions(appId: string, profileId: string): Promise<ReadIndexVersions>;
+    invalidateTeam(appId: string, profileId: string, teamId: string, version: number, knownThreadIds?: readonly string[]): Promise<ReadIndexState>;
+    update(appId: string, profileId: string, transform: ReadIndexTransform): Promise<ReadIndexState>;
     close(): Promise<void>;
 }
 export declare function sourcesInConversation(state: ReadIndexState, conversationId: string): IndexedReadThread[];
 /** Aggregate logical history while each original source retains its own read cursor. */
-export declare function unreadInConversation(state: ReadIndexState, conversationId: string): {
+export declare function unreadInConversation(state: ReadIndexState, conversationId: string, hidden?: ReadonlyMap<string, ReadonlySet<string>>): {
     unreadMessageCount: number;
     unreadMentionCount: number;
     badgeCount: number;