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

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;
@@ -64,6 +71,7 @@ export declare function installReadSnapshot(current: ReadIndexState, snapshot: R
 export declare function applyReadChange(current: ReadIndexState, change: ReadChange): ReadIndexState;
 /** Persist observations even if the message arrived before its Sequence metadata. */
 export declare function recordReadIntent(current: ReadIndexState, intent: ObservedReadIntent): ReadIndexState;
+export declare function resolveObservedReads(current: ReadIndexState): ReadIndexState;
 /** Called only for a message the visible viewport actually reached. */
 export declare function recordVisibleRead(current: ReadIndexState, threadId: string, messageId: string, operationId: string): ReadIndexState;
 export declare function recordExplicitRead(current: ReadIndexState, threadId: string, messageId: string, operationId: string): ReadIndexState;
@@ -72,32 +80,85 @@ 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;
+/** Internal hint for typed reading observations; arbitrary transforms omit it. */
+export type ReadObservationScope = {
+    base: ReadIndexState;
+    targets: readonly {
+        threadId: string;
+        messageId: string;
+    }[];
+};
 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, observation?: ReadObservationScope): Promise<ReadIndexState>;
 }
-/** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
+/** Preserves the database and logical keys; store renaming fences old format writers. */
 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 orderedStates;
+    private legacyClean;
+    private observationMessages;
+    private versions;
     private closed;
-    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined);
+    private journal;
+    private factory;
+    private schemaReady;
+    private ownerTail;
+    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined, migrateLegacy?: boolean, metadataOnly?: boolean);
+    private owned;
     private transaction;
     private key;
+    /** Keyset pages avoid materializing a second, unbounded array of durable rows.
+     * Keep the caller's transaction so every page belongs to one consistent view. */
+    private readPages;
+    private hydrate;
+    private loadCurrent;
+    private loadStored;
+    private cleanupClaimedLegacy;
     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>;
+    private observe;
+    update(appId: string, profileId: string, transform: ReadIndexTransform, observation?: ReadObservationScope): Promise<ReadIndexState>;
+    private updateOwned;
+    private writeState;
+    private cleanUnreachable;
+    private changes;
     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;