@pmate/chat-sdk 0.12.0-next.27 → 0.12.0-next.29

package/lib/runtime/chatSession.d.ts

@@ -1,3 +1,5 @@
+import { type TimelineItem } from "./messageTimeline.js";
+import { type ReadingCandidate, type MessageReadingState } from "./conversationReading.js";
 import type { ConversationReadMessage } from "./conversationRead.js";
 import { type ReadCountsResult } from "./readCounts.js";
 import type { OnlineReachEvent } from "./reach.js";
@@ -16,21 +18,25 @@ export type ChatSessionOptions<T extends StoredMessage> = {
     activeThreadId?: string;
     reading: ReadingClientOptions;
     decode: (message: ChatRuntimeMessage) => T | undefined;
+    readingCandidate?: (message: T) => ReadingCandidate | undefined;
     onError: (error: unknown) => void;
 };
 export type ChatThreadSnapshot<T> = {
     messages: readonly T[];
+    timeline: readonly TimelineItem<T>[];
     outgoing: ReturnType<DurableChatSender["snapshot"]>;
     hasEarlier: boolean;
     resetVersion: number;
     complete: boolean;
     readCounts?: ReadCountsResult;
     unread: ReturnType<typeof unreadInConversation> | undefined;
+    messageReading: Readonly<Record<string, MessageReadingState>>;
 };
 export type ChatSummarySnapshot<T> = {
     threads: readonly {
         threadId: string;
         lastMessage?: T;
+        lastItem?: TimelineItem<T>;
         unread: ChatThreadSnapshot<T>["unread"];
         outgoingCount: number;
     }[];
@@ -54,6 +60,8 @@ export declare class ChatSession<T extends StoredMessage> {
     private sender;
     private listeners;
     private snapshots;
+    private timelineDecoded;
+    private decodeTimeline;
     private historyEdges;
     private earlierReads;
     private off;
@@ -125,6 +133,7 @@ export declare class ChatSession<T extends StoredMessage> {
     private watchCounts;
     getSnapshot(): ChatSummarySnapshot<T>;
     getSnapshot(threadId: string): ChatThreadSnapshot<T>;
+    private buildThreadSnapshot;
     subscribe(listener: () => void): () => void;
     subscribe(threadId: string, listener: () => void, fields?: readonly (keyof ChatThreadSnapshot<T>)[]): () => void;
     private publishAll;

package/lib/runtime/chatSession.js

@@ -1,3 +1,5 @@
+import { projectMessageTimeline } from "./messageTimeline.js";
+import { projectConversationReading } from "./conversationReading.js";
 import { ReadCountsClient } from "./readCounts.js";
 import { WindowedTasks } from "./coalescer.js";
 import { MessageReadersClient } from "./messageReaders.js";
@@ -22,12 +24,15 @@ export class ChatSession {
     sender;
     listeners = new Map();
     snapshots = new Map();
+    timelineDecoded = new WeakMap();
+    decodeTimeline = (message) => { if (!this.timelineDecoded.has(message))
+        this.timelineDecoded.set(message, this.options.decode(message)); return this.timelineDecoded.get(message); };
     historyEdges = new Map();
     earlierReads = new Map();
     off = [];
     globalListeners = new Set();
     globalSnapshot;
-    closedThread = { messages: [], outgoing: [], hasEarlier: false, resetVersion: 0, complete: false, unread: undefined };
+    closedThread = { messages: [], timeline: [], outgoing: [], hasEarlier: false, resetVersion: 0, complete: false, unread: undefined, messageReading: {} };
     closedSummary = { threads: [], unreadMessageCount: undefined, badgeCount: undefined, connection: "closed" };
     connectionState = "closed";
     catchUp;
@@ -428,13 +433,26 @@ export class ChatSession {
         }
         let snapshot = this.snapshots.get(threadId);
         if (!snapshot) {
-            const messages = this.messages.getSnapshot(threadId);
-            const state = this.getReadingSnapshot();
-            snapshot = { messages: messages?.messages ?? [], hasEarlier: messages?.hasEarlier ?? false, resetVersion: messages?.resetVersion ?? 0, complete: messages?.complete ?? false, outgoing: this.sender.snapshot(threadId), readCounts: this.countSnapshots.get(threadId), unread: state?.threads.some(thread => (thread.conversationId ?? thread.id) === threadId) ? unreadInConversation(state, threadId) : undefined };
+            snapshot = this.buildThreadSnapshot(threadId);
             this.snapshots.set(threadId, snapshot);
         }
         return snapshot;
     }
+    buildThreadSnapshot(threadId, previous) {
+        const messages = this.messages.getSnapshot(threadId);
+        const state = this.getReadingSnapshot();
+        const candidates = messages?.messages.flatMap(message => { const candidate = this.options.readingCandidate?.(message); return candidate ? [candidate] : []; }) ?? [];
+        const sources = state?.threads.filter(thread => (thread.conversationId ?? thread.id) === threadId) ?? [];
+        const kind = sources[0]?.kind ?? "dm";
+        const view = projectConversationReading(state, { id: threadId, kind }, candidates);
+        const unread = previous && JSON.stringify(previous.unread) === JSON.stringify(view.unread) ? previous.unread : view.unread;
+        const messageReading = previous && JSON.stringify(previous.messageReading) === JSON.stringify(view.messageReading) ? previous.messageReading : view.messageReading;
+        const raw = messages?.messages ?? [];
+        const stableMessages = previous && previous.messages.length === raw.length && previous.messages.every((message, index) => message === raw[index]) ? previous.messages : raw;
+        const outgoing = this.sender.snapshot(threadId);
+        const timeline = projectMessageTimeline({ appId: this.options.messages.scope.appId, profileId: this.options.messages.scope.profileId, threadId, messages: stableMessages, outgoing, decode: this.decodeTimeline, reading: messageReading, previous: previous?.timeline });
+        return { timeline, messages: stableMessages, hasEarlier: messages?.hasEarlier ?? false, resetVersion: messages?.resetVersion ?? 0, complete: messages?.complete ?? false, outgoing, readCounts: this.countSnapshots.get(threadId), unread, messageReading };
+    }
     subscribe(target, listener, fields) {
         if (this.closed || this.withdrawn)
             return () => { };
@@ -483,7 +501,7 @@ export class ChatSession {
             ids.add(outgoing.threadId);
         const threads = [...ids].sort().map(threadId => {
             const snapshot = this.getSnapshot(threadId);
-            return { threadId, lastMessage: snapshot.messages.at(-1), unread: snapshot.unread, outgoingCount: snapshot.outgoing.length };
+            return { threadId, lastMessage: snapshot.timeline.at(-1)?.message, lastItem: snapshot.timeline.at(-1), unread: snapshot.unread, outgoingCount: snapshot.outgoing.length };
         });
         const state = this.getReadingSnapshot();
         const known = Boolean(state && state.syncCursor !== "0" && threads.every(thread => thread.unread !== undefined));
@@ -493,7 +511,11 @@ export class ChatSession {
         if (this.closed || this.withdrawn)
             return;
         const next = this.buildGlobal();
-        if (JSON.stringify(next) === JSON.stringify(this.globalSnapshot))
+        const previous = this.globalSnapshot;
+        if (previous && previous.connection === next.connection && previous.unreadMessageCount === next.unreadMessageCount && previous.badgeCount === next.badgeCount && previous.threads.length === next.threads.length && previous.threads.every((thread, index) => {
+            const other = next.threads[index];
+            return thread.threadId === other.threadId && thread.lastMessage === other.lastMessage && thread.lastItem === other.lastItem && thread.outgoingCount === other.outgoingCount && JSON.stringify(thread.unread) === JSON.stringify(other.unread);
+        }))
             return;
         this.globalSnapshot = next;
         this.globalListeners.forEach(listener => listener());
@@ -501,8 +523,9 @@ export class ChatSession {
     publish(threadId, notifyGlobal = true) {
         const previous = this.snapshots.get(threadId);
         this.snapshots.delete(threadId);
-        const next = this.getSnapshot(threadId);
-        if (previous && JSON.stringify(previous) === JSON.stringify(next)) {
+        const next = this.buildThreadSnapshot(threadId, previous);
+        this.snapshots.set(threadId, next);
+        if (previous && previous.messages === next.messages && previous.timeline === next.timeline && previous.outgoing.length === next.outgoing.length && previous.outgoing.every((record, index) => record === next.outgoing[index]) && previous.hasEarlier === next.hasEarlier && previous.resetVersion === next.resetVersion && previous.complete === next.complete && previous.readCounts === next.readCounts && JSON.stringify(previous.unread) === JSON.stringify(next.unread) && JSON.stringify(previous.messageReading) === JSON.stringify(next.messageReading)) {
             this.snapshots.set(threadId, previous);
             return;
         }
@@ -528,6 +551,7 @@ export class ChatSession {
         this.counts?.watch(undefined, []);
         this.countSnapshots.clear();
         this.snapshots.clear();
+        this.timelineDecoded = new WeakMap();
         this.historyEdges.clear();
         this.earlierReads.clear();
         this.globalSnapshot = undefined;
@@ -593,6 +617,7 @@ export class ChatSession {
                 this.globalListeners.clear();
                 this.readingListeners.clear();
                 this.snapshots.clear();
+                this.timelineDecoded = new WeakMap();
                 this.countSnapshots.clear();
                 this.historyEdges.clear();
                 this.earlierReads.clear();

package/lib/runtime/conversationReading.d.ts

@@ -0,0 +1,28 @@
+import { unreadInConversation, type ReadIndexState } from "./readIndex.js";
+export type ReadingCandidate = {
+    id: string;
+    threadId: string;
+    from?: string;
+    mine?: boolean;
+    recalled?: boolean;
+    unread?: boolean;
+    attentionEligible?: boolean;
+    readPolicy?: "visible" | "explicit";
+};
+export type MessageReadingState = {
+    seq?: number;
+    read: boolean;
+    readPolicy: "visible" | "explicit";
+};
+export type ConversationReadingView = {
+    messageReading: Readonly<Record<string, MessageReadingState>>;
+    unread: ReturnType<typeof unreadInConversation> | undefined;
+    badgeCount: number | undefined;
+};
+/** One projection for indexed authority and observations awaiting indexing. A
+ * directory badge is optional compatibility metadata, never proof of coverage. */
+export declare function projectConversationReading(state: ReadIndexState | undefined, conversation: {
+    id: string;
+    kind: "dm" | "group";
+    badgeCount?: number;
+}, candidates?: readonly ReadingCandidate[]): ConversationReadingView;

package/lib/runtime/conversationReading.js

@@ -0,0 +1,43 @@
+import { sourcesInConversation, unreadInConversation } from "./readIndex.js";
+/** One projection for indexed authority and observations awaiting indexing. A
+ * directory badge is optional compatibility metadata, never proof of coverage. */
+export function projectConversationReading(state, conversation, candidates = []) {
+    const sources = state ? sourcesInConversation(state, conversation.id) : [];
+    const sourceIds = new Set([conversation.id, ...sources.map(source => source.id)]);
+    const indexed = new Set(), messageReading = Object.create(null);
+    for (const source of sources)
+        for (const message of source.messages) {
+            indexed.add(message.id);
+            messageReading[message.id] = { seq: message.seq, readPolicy: message.readPolicy, read: message.recalled || message.from === state.profileId || !message.recipients.includes(state.profileId) || (message.readPolicy === "explicit" ? source.explicitReadMessageIds.includes(message.id) : message.seq <= source.readThroughSeq) };
+        }
+    const observed = new Map();
+    for (const intent of state?.observedReadIntents ?? [])
+        if (sourceIds.has(intent.threadId)) {
+            if (!observed.has(intent.messageId))
+                observed.set(intent.messageId, new Set());
+            observed.get(intent.messageId).add(intent.readPolicy);
+        }
+    const unique = new Map(candidates.filter(message => message.threadId === conversation.id).map(message => [message.id, message]));
+    let pendingMessages = 0, pendingMentions = 0, observedBadges = 0;
+    for (const message of unique.values()) {
+        const incoming = !message.mine && message.from !== state?.profileId && !message.recalled;
+        const attention = conversation.kind === "dm" || message.attentionEligible === true;
+        const policy = message.readPolicy ?? "visible";
+        const acknowledged = observed.get(message.id)?.has(policy) === true;
+        if (!indexed.has(message.id) && acknowledged)
+            messageReading[message.id] = { read: true, readPolicy: policy };
+        if (!incoming)
+            continue;
+        if (acknowledged && attention)
+            observedBadges++;
+        if (indexed.has(message.id) || acknowledged || message.unread !== true)
+            continue;
+        pendingMessages++;
+        if (message.attentionEligible === true)
+            pendingMentions++;
+    }
+    const authoritative = sources.length && state ? unreadInConversation(state, conversation.id) : undefined;
+    const unread = authoritative ? { unreadMessageCount: authoritative.unreadMessageCount + pendingMessages, unreadMentionCount: authoritative.unreadMentionCount + pendingMentions, badgeCount: authoritative.badgeCount + (conversation.kind === "group" ? pendingMentions : pendingMessages) } : undefined;
+    const pendingBadge = conversation.kind === "group" ? pendingMentions : pendingMessages;
+    return { messageReading, unread, badgeCount: unread?.badgeCount ?? (conversation.badgeCount === undefined ? undefined : Math.max(Math.max(0, conversation.badgeCount - observedBadges), pendingBadge)) };
+}

package/lib/runtime/createChat.js

@@ -1,3 +1,4 @@
+import { isReadingControl } from "./readingContent.js";
 import { ChatSession } from "./chatSession.js";
 import { SocialReadClient } from "./socialReadClient.js";
 import { chatTeamId } from "./teamScope.js";
@@ -21,6 +22,15 @@ export function createChat(options) {
         reading: { appId, profileId, sessionToken: token, hubHttpUrl: http, fetch: options.fetch, onError },
         connection: { appId, profileId, teamId, hubUrl: ws, clientInstanceId: options.clientInstanceId, fetchImpl: options.fetch,
             session: { token, identity: { accountId, app: appId, profileId } }, onNotification: options.onNotification, onReach: options.onReach },
+        readingCandidate: message => {
+            if (isReadingControl(message.body, appId))
+                return undefined;
+            const body = message.body;
+            if (!body || !["message", "quote"].includes(String(body.kind)) && !(body.kind === "contact" && ["friendRequest", "requestFriend"].includes(String(body.action))))
+                return undefined;
+            return { id: message.id, threadId: message.threadId, from: message.from, mine: message.from === profileId, recalled: message.recalled, unread: message.from !== profileId,
+                readPolicy: body?.contentKind === "voice" ? "explicit" : "visible", attentionEligible: Array.isArray(body.content?.mentions) && body.content.mentions.some(mention => mention?.id === profileId) };
+        },
         decode: message => decodeIncoming(message, { appId, profileId, teamId }), onError,
     });
 }

package/lib/runtime/index.d.ts

@@ -30,3 +30,5 @@ export * from "./chatSession.js";
 export * from "./messageReaders.js";
 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 } from "./messageTimeline.js";

package/lib/runtime/index.js

@@ -30,3 +30,5 @@ export * from "./chatSession.js";
 export * from "./messageReaders.js";
 export * from "./createChat.js";
 export * from "./conversationRead.js";
+export { projectConversationReading } from "./conversationReading.js";
+export { projectMessageTimeline } from "./messageTimeline.js";

package/lib/runtime/messageTimeline.d.ts

@@ -0,0 +1,33 @@
+import type { StoredMessage } from "./messageStore.js";
+import type { OutgoingMessage } from "./durableSender.js";
+import type { ChatRuntimeMessage } from "./protocol.js";
+import type { MessageReadingState } from "./conversationReading.js";
+export type TimelineReaction = {
+    emojiId: string;
+    userIds: string[];
+    mine: boolean;
+};
+export type TimelineItem<T> = {
+    id: string;
+    threadId: string;
+    timestamp: number;
+    from?: string;
+    mine: boolean;
+    status: "sending" | "sent" | "failed" | "read";
+    recalled: boolean;
+    message: T | undefined;
+    reading?: MessageReadingState;
+    reactions: readonly TimelineReaction[];
+};
+/** Derives one display stream without copying bodies or creating another cache.
+ * Outgoing rows retain their wire identity; indexed rows take precedence. */
+export declare function projectMessageTimeline<T extends StoredMessage>(input: {
+    appId: string;
+    profileId: string;
+    threadId: string;
+    messages: readonly T[];
+    outgoing: readonly OutgoingMessage[];
+    decode: (message: ChatRuntimeMessage) => T | undefined;
+    reading: Readonly<Record<string, MessageReadingState>>;
+    previous?: readonly TimelineItem<T>[];
+}): readonly TimelineItem<T>[];

package/lib/runtime/messageTimeline.js

@@ -0,0 +1,98 @@
+import { isReadingControl } from "./readingContent.js";
+function content(message, appId) {
+    const body = message.body;
+    return body?.kind === "message" && body.content?.appId === appId ? body : 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 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))
+            records.set(message.id, { message, status: "sent" });
+    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" && isReadingControl(message.body, input.appId))
+            continue;
+        const envelope = message, body = content(envelope, input.appId), target = 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 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 (isReadingControl(envelope.body, input.appId))
+            continue;
+        const mine = envelope.from === input.profileId, reading = input.reading[message.id];
+        const withdrawn = Boolean(message.recalled || envelope.legacyDisplay?.recalled || envelope.from && recalled.get(message.id)?.has(envelope.from));
+        const item = { id: message.id, threadId: message.threadId, timestamp: message.timestamp, from: envelope.from, mine, status: !mine && reading?.read ? "read" : status, recalled: withdrawn,
+            message: withdrawn ? undefined : message, reading, 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]); });
+        result.push(old && old.message === item.message && old.timestamp === item.timestamp && old.from === item.from && old.mine === item.mine && old.status === item.status && old.recalled === item.recalled && 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/readIndex.js

@@ -1,4 +1,5 @@
 import { Dexie } from "dexie";
+import { isReadingControl } from "./readingContent.js";
 import { isValidChatTeamId } from "./thread.js";
 export class ReadSyncGap extends Error {
     cursor;
@@ -158,7 +159,7 @@ export function unreadInThread(state, threadId) {
     if (!thread)
         throw new Error("UNKNOWN_READ_THREAD");
     const explicit = new Set(thread.explicitReadMessageIds);
-    const messages = thread.messages.filter(message => !message.recalled && message.from !== state.profileId && message.recipients.includes(state.profileId)
+    const messages = thread.messages.filter(message => !message.recalled && !isReadingControl(message.payload, state.appId) && message.from !== state.profileId && message.recipients.includes(state.profileId)
         && (message.readPolicy === "explicit" ? !explicit.has(message.id) : message.seq > thread.readThroughSeq));
     const unreadMessageCount = messages.length;
     const unreadMentionCount = messages.filter(message => message.mentions.includes(state.profileId)).length;

package/lib/runtime/readingContent.d.ts

@@ -0,0 +1,2 @@
+/** Social control envelopes do not contribute to message unread counts. */
+export declare function isReadingControl(payload: unknown, appId: string): boolean;

package/lib/runtime/readingContent.js

@@ -0,0 +1,9 @@
+/** Social control envelopes do not contribute to message unread counts. */
+export function isReadingControl(payload, appId) {
+    if (!payload || typeof payload !== "object")
+        return false;
+    const value = payload;
+    if (value.body !== undefined)
+        return isReadingControl(value.body, appId);
+    return value.kind === "message" && value.content?.appId === appId && (value.content.reaction !== undefined || value.content.recall !== undefined);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.27",
+  "version": "0.12.0-next.29",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",