@pmate/chat-sdk 0.9.10 → 0.10.0

package/README.md

@@ -72,3 +72,16 @@ are explicit errors.
 and withholds incomplete charts. A revision gap requires fetching a snapshot.
 This reducer does not itself create a network stream; the sender must provide
 updates and the receiver must preserve its existing identity/authorization checks.
+
+
+## Team conversations
+
+### Background
+
+A profile can belong to several existing organizations. Pass the organization's stable ID as `teamId` to keep conversations separate; never use the team's display name as identity. A compatible Hub must validate membership before accepting Team messages.
+
+`dmThreadId(appId, ownProfileId, peerProfileId, teamId)` and `groupThreadId(appId, groupId, teamId)` produce Team-specific IDs matching Rust social. Omitting `teamId` retains the legacy ID for migration lookup and existing unscoped apps. `ChatClient` accepts a default `teamId`; `sendDm`, `sendGroup`, group operations, contact actions and activity targets also accept explicit scope. Conflicting explicit and default scopes are rejected. Raw `sendChat` callers can use `withChatTeam(body, teamId)`.
+
+`TeamMigrationClient.plan(peerId)` reads the authenticated caller's legacy history summary and common Team candidates. `assign(peerId, teamId)` submits a durable ownership decision. A `pending` result means the indexer has not confirmed the result: plan again, do not report success yet. `TeamMigrationError` with status 409 includes the winning assignment when concurrent selections conflict.
+
+Migrated reading snapshots retain source `id`/sequence positions and add `conversationId`/`teamId`. Use `sourcesInConversation` and `unreadInConversation` to render the logical conversation. `recordReadIntent` resolves the message back to its durable source, preserving old offline pending reads and explicit voice reads. Do not merge different sources' sequence numbers into a single cursor.

package/lib/index.d.ts

@@ -35,3 +35,5 @@ export * from "./runtime/activity";
 export * from "./runtime/call";
 export * from "./runtime/presence";
 export * from "./runtime/meeting";
+export * from "./runtime/teamScope";
+export * from "./runtime/teamMigrations";

package/lib/index.js

@@ -35,3 +35,5 @@ export * from "./runtime/activity";
 export * from "./runtime/call";
 export * from "./runtime/presence";
 export * from "./runtime/meeting";
+export * from "./runtime/teamScope";
+export * from "./runtime/teamMigrations";

package/lib/runtime/activity.d.ts

@@ -3,6 +3,7 @@ export type ChatActivityState = "working" | "typing" | "idle";
 export type ChatActivityBody = {
     kind: "activity";
     appId: string;
+    teamId?: string;
     threadKind: "dm" | "group";
     activityId: string;
     seq: number;
@@ -23,6 +24,7 @@ export type ChatActivity = ChatActivityBody & {
 };
 export type ActivityTarget = {
     to: string;
+    teamId?: string;
     threadKind?: "dm" | "group";
     recipients?: string[];
     replyTo?: string;

package/lib/runtime/activity.js

@@ -1,8 +1,11 @@
 import { ChatMsgOp, createRuntimeMsg } from "./protocol.js";
-import { dmThreadId, groupThreadId } from "./thread.js";
+import { dmThreadId, groupThreadId, isValidChatTeamId } from "./thread.js";
 export const ACTIVITY_TTL_MS = 15_000;
 export function createActivityMessage(input) {
+    if (input.teamId !== undefined && !isValidChatTeamId(input.teamId))
+        throw new Error("Invalid chat teamId");
     const body = { kind: "activity", appId: input.appId, threadKind: input.threadKind ?? "dm", activityId: input.activityId, seq: input.seq, state: input.state, ttlMs: ACTIVITY_TTL_MS,
+        ...(input.teamId !== undefined ? { teamId: input.teamId } : {}),
         ...(input.phase ? { phase: input.phase } : {}),
         ...(input.replyTo ? { replyTo: input.replyTo } : {}),
         ...(input.detail ? { detail: Array.from(input.detail).slice(0, 120).join("") } : {}) };
@@ -16,6 +19,7 @@ export function parseChatActivity(message, appId, profileId, now = Date.now()) {
     if (message.opcode !== ChatMsgOp.CHAT || body?.kind !== "activity" || body.appId !== appId || !message.from || message.from === profileId || !message.to
         || (body.threadKind !== "dm" && body.threadKind !== "group")
         || (body.threadKind === "dm" ? message.to !== profileId : !message.recipients?.includes(profileId))
+        || (body.teamId !== undefined && !isValidChatTeamId(body.teamId))
         || typeof body.activityId !== "string" || !body.activityId || body.activityId.length > 128
         || !Number.isSafeInteger(body.seq) || body.seq < 0
         || !["working", "typing", "idle"].includes(body.state ?? "")
@@ -26,7 +30,7 @@ export function parseChatActivity(message, appId, profileId, now = Date.now()) {
         || (body.detail !== undefined && (typeof body.detail !== "string" || Array.from(body.detail).length > 120)))
         return null;
     return { ...body, from: message.from, to: message.to,
-        threadId: body.threadKind === "dm" ? dmThreadId(appId, message.from, profileId) : groupThreadId(appId, message.to),
+        threadId: body.threadKind === "dm" ? dmThreadId(appId, message.from, profileId, body.teamId) : groupThreadId(appId, message.to, body.teamId),
         updatedAt: message.t, expiresAt: Math.min(message.t + body.ttlMs, now + ACTIVITY_TTL_MS) };
 }
 /** Keeps ordering tombstones after completion so a late heartbeat cannot revive an activity. */
@@ -56,7 +60,7 @@ export class ChatActivityStore {
             return;
         let changed = false;
         for (const [key, record] of this.records) {
-            if (record.from === message.from && record.to === message.to && record.threadKind === body.threadKind && (record.replyTo && body.content?.replyTo ? record.replyTo === body.content.replyTo : record.updatedAt <= message.t) && record.state !== "idle") {
+            if (record.teamId === body.content?.teamId && record.from === message.from && record.to === message.to && record.threadKind === body.threadKind && (record.replyTo && body.content?.replyTo ? record.replyTo === body.content.replyTo : record.updatedAt <= message.t) && record.state !== "idle") {
                 this.records.set(key, { ...record, state: "idle" });
                 changed = true;
             }

package/lib/runtime/chatClient.d.ts

@@ -10,6 +10,7 @@ import { type ChatBody, type ChatRuntimeMessage, type RealtimeClient } from "./p
 export type ChatConnectionState = "connecting" | "reconnecting" | "authenticating" | "connected" | "authentication_required" | "closed";
 export type ChatClientOptions = {
     appId: string;
+    teamId?: string;
     clientInstanceId?: string;
     onReach?: OnlineReachHandler;
     onNotification?: OnlineNotificationHandler;
@@ -72,33 +73,40 @@ export declare class ChatClient {
     startActivity(target: ActivityTarget, initial?: ChatActivityUpdate): ChatActivityPublisher;
     requestFriend(input: {
         to: string;
+        teamId?: string;
         message?: string;
     }): Promise<ChatRuntimeMessage>;
     acceptFriend(input: {
         to: string;
+        teamId?: string;
         requestId?: string;
         message?: string;
     }): Promise<ChatRuntimeMessage>;
     rejectFriend(input: {
         to: string;
+        teamId?: string;
         requestId?: string;
         reason?: string;
     }): Promise<ChatRuntimeMessage>;
     removeFriend(input: {
         to: string;
+        teamId?: string;
         reason?: string;
     }): Promise<ChatRuntimeMessage>;
     sendDm(input: {
         to: string;
         text: string;
+        teamId?: string;
     }): Promise<ChatRuntimeMessage>;
     createGroup(input: {
         groupId: string;
+        teamId?: string;
         members: string[];
         title?: string;
     }): Promise<ChatRuntimeMessage>;
     updateGroup(input: {
         groupId: string;
+        teamId?: string;
         expectedRevision: string;
         addMembers?: string[];
         removeMembers?: string[];
@@ -107,6 +115,7 @@ export declare class ChatClient {
     }): Promise<ChatRuntimeMessage>;
     sendGroup(input: {
         groupId: string;
+        teamId?: string;
         text: string;
         recipients?: string[];
         mentions?: ChatMention[];

package/lib/runtime/chatClient.js

@@ -1,3 +1,4 @@
+import { withChatTeam } from "./teamScope.js";
 import { OnlineReachReceiver } from "./reach.js";
 import { OnlineNotificationReceiver } from "./notification.js";
 import { ChatPresenceClient } from "./presence.js";
@@ -175,7 +176,9 @@ export class ChatClient {
     }
     watchActivities(handler) { return this.activities.watch(handler); }
     async sendActivity(input) {
-        const message = createActivityMessage({ ...input, from: this.profileId(), appId: this.options.appId });
+        if (input.teamId !== undefined && this.options.teamId !== undefined && input.teamId !== this.options.teamId)
+            throw new Error("Chat teamId does not match the active team");
+        const message = createActivityMessage({ ...input, teamId: this.options.teamId ?? input.teamId, from: this.profileId(), appId: this.options.appId });
         await this.sendAndWaitForAck(message);
         return message;
     }
@@ -191,22 +194,26 @@ export class ChatClient {
     async requestFriend(input) {
         return this.sendContactAction(input.to, "friendRequest", {
             message: input.message,
+            ...(input.teamId !== undefined ? { teamId: input.teamId } : {}),
         });
     }
     async acceptFriend(input) {
         return this.sendContactAction(input.to, "friendAccept", {
+            ...(input.teamId !== undefined ? { teamId: input.teamId } : {}),
             requestId: input.requestId,
             message: input.message,
         });
     }
     async rejectFriend(input) {
         return this.sendContactAction(input.to, "friendReject", {
+            ...(input.teamId !== undefined ? { teamId: input.teamId } : {}),
             requestId: input.requestId,
             reason: input.reason,
         });
     }
     async removeFriend(input) {
         return this.sendContactAction(input.to, "friendRemove", {
+            ...(input.teamId !== undefined ? { teamId: input.teamId } : {}),
             reason: input.reason,
         });
     }
@@ -215,7 +222,7 @@ export class ChatClient {
             kind: "message",
             threadKind: "dm",
             contentKind: "text",
-            content: { appId: this.options.appId, text: input.text },
+            content: { appId: this.options.appId, text: input.text, ...(input.teamId !== undefined ? { teamId: input.teamId } : {}) },
         });
     }
     async createGroup(input) {
@@ -226,6 +233,7 @@ export class ChatClient {
             payload: {
                 appId: this.options.appId,
                 groupId: input.groupId,
+                ...(input.teamId !== undefined ? { teamId: input.teamId } : {}),
                 members: input.members,
                 title: input.title,
             },
@@ -234,7 +242,7 @@ export class ChatClient {
     async updateGroup(input) {
         return this.sendChat(input.groupId, {
             kind: "group", threadKind: "group", action: "groupUpdate",
-            payload: { appId: this.options.appId, groupId: input.groupId, expectedRevision: input.expectedRevision,
+            payload: { appId: this.options.appId, groupId: input.groupId, ...(input.teamId !== undefined ? { teamId: input.teamId } : {}), expectedRevision: input.expectedRevision,
                 addMembers: input.addMembers ?? [], removeMembers: input.removeMembers ?? [], ...(input.title !== undefined ? { title: input.title } : {}), ...(input.avatar !== undefined ? { avatar: input.avatar } : {}) },
         });
     }
@@ -243,11 +251,11 @@ export class ChatClient {
             kind: "message",
             threadKind: "group",
             contentKind: "text",
-            content: { appId: this.options.appId, groupId: input.groupId, text: input.text, ...(input.mentions?.length ? { mentions: input.mentions } : {}) },
+            content: { appId: this.options.appId, groupId: input.groupId, ...(input.teamId !== undefined ? { teamId: input.teamId } : {}), text: input.text, ...(input.mentions?.length ? { mentions: input.mentions } : {}) },
         }, input.recipients);
     }
     async sendChat(to, body, recipients) {
-        const msg = createRuntimeMsg(this.profileId(), to, ChatMsgOp.CHAT, body, ChatMsgKind.DM);
+        const msg = createRuntimeMsg(this.profileId(), to, ChatMsgOp.CHAT, withChatTeam(body, this.options.teamId), ChatMsgKind.DM);
         if (recipients) {
             msg.recipients = recipients;
         }

package/lib/runtime/index.d.ts

@@ -15,3 +15,5 @@ export * from "./meeting.js";
 export * from "./notification.js";
 export * from "./readSync.js";
 export * from "./reach.js";
+export * from "./teamScope.js";
+export * from "./teamMigrations.js";

package/lib/runtime/index.js

@@ -15,3 +15,5 @@ export * from "./meeting.js";
 export * from "./notification.js";
 export * from "./readSync.js";
 export * from "./reach.js";
+export * from "./teamScope.js";
+export * from "./teamMigrations.js";

package/lib/runtime/readIndex.d.ts

@@ -18,7 +18,11 @@ export type ReadingOperation = {
     explicitReadMessageIds: string[];
 };
 export type IndexedReadThread = {
+    /** Durable source ID: reading positions must remain attached to this ID. */
     id: string;
+    teamId?: string;
+    /** Present when historical source data has been assigned to a team conversation. */
+    conversationId?: string;
     kind: "dm" | "group";
     messages: IndexedReadMessage[];
     readThroughSeq: number;
@@ -86,3 +90,10 @@ export declare class IndexedDbReadIndex implements ReadIndexPersistence {
     update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): 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): {
+    unreadMessageCount: number;
+    unreadMentionCount: number;
+    badgeCount: number;
+};

package/lib/runtime/readIndex.js

@@ -1,3 +1,4 @@
+import { isValidChatTeamId } from "./thread.js";
 export class ReadSyncGap extends Error {
     cursor;
     constructor(cursor) {
@@ -11,6 +12,10 @@ export function createReadIndex(appId, profileId) {
 function validateThread(thread) {
     if (!thread.id || !["dm", "group"].includes(thread.kind) || !Number.isSafeInteger(thread.readThroughSeq) || thread.readThroughSeq < 0)
         throw new Error("INVALID_READ_THREAD");
+    if (thread.teamId !== undefined && !isValidChatTeamId(thread.teamId))
+        throw new Error("INVALID_READ_TEAM");
+    if (thread.conversationId !== undefined && (!thread.conversationId || !thread.teamId))
+        throw new Error("INVALID_READ_CONVERSATION");
     const ids = new Set(), positions = new Set();
     for (const message of thread.messages) {
         if (!message.id || !Number.isSafeInteger(message.seq) || message.seq < 1 || ids.has(message.id) || positions.has(message.seq)
@@ -89,7 +94,7 @@ function resolveObservedReads(current) {
     let next = current;
     const remaining = [];
     for (const intent of current.observedReadIntents ?? []) {
-        const message = next.threads.find(thread => thread.id === intent.threadId)?.messages.find(message => message.id === intent.messageId);
+        const message = readSource(next, intent.threadId, intent.messageId)?.messages.find(message => message.id === intent.messageId);
         if (!message) {
             remaining.push(intent);
             continue;
@@ -105,22 +110,22 @@ function resolveObservedReads(current) {
 }
 /** Called only for a message the visible viewport actually reached. */
 export function recordVisibleRead(current, threadId, messageId, operationId) {
-    const thread = current.threads.find(t => t.id === threadId);
+    const thread = readSource(current, threadId, messageId);
     const message = thread?.messages.find(m => m.id === messageId);
     if (!thread || !message || message.readPolicy !== "visible")
         throw new Error("INVALID_VISIBLE_READ");
     if (message.seq <= thread.readThroughSeq)
         return current;
-    return enqueue(current, { operationId, threadId, readThroughSeq: message.seq, readThroughMessageId: message.id, explicitReadMessageIds: [] });
+    return enqueue(current, { operationId, threadId: thread.id, readThroughSeq: message.seq, readThroughMessageId: message.id, explicitReadMessageIds: [] });
 }
 export function recordExplicitRead(current, threadId, messageId, operationId) {
-    const thread = current.threads.find(t => t.id === threadId);
+    const thread = readSource(current, threadId, messageId);
     const message = thread?.messages.find(m => m.id === messageId);
     if (!thread || !message || message.readPolicy !== "explicit")
         throw new Error("INVALID_EXPLICIT_READ");
     if (thread.explicitReadMessageIds.includes(messageId))
         return current;
-    return enqueue(current, { operationId, threadId, readThroughSeq: 0, explicitReadMessageIds: [messageId] });
+    return enqueue(current, { operationId, threadId: thread.id, readThroughSeq: 0, explicitReadMessageIds: [messageId] });
 }
 function enqueue(current, operation) {
     if (!operation.operationId || current.pending.some(p => p.operationId === operation.operationId))
@@ -207,3 +212,24 @@ export class IndexedDbReadIndex {
     }
     async close() { (await this.database).close(); }
 }
+export function sourcesInConversation(state, conversationId) {
+    return state.threads.filter(thread => (thread.conversationId ?? thread.id) === conversationId);
+}
+function readSource(state, conversationId, messageId) {
+    const sources = state.threads.filter(thread => (thread.id === conversationId || thread.conversationId === conversationId) && thread.messages.some(message => message.id === messageId));
+    if (sources.length > 1)
+        throw new Error("AMBIGUOUS_READ_SOURCE");
+    return sources[0];
+}
+/** Aggregate logical history while each original source retains its own read cursor. */
+export function unreadInConversation(state, conversationId) {
+    const sources = sourcesInConversation(state, conversationId);
+    if (!sources.length)
+        throw new Error("UNKNOWN_READ_CONVERSATION");
+    if (new Set(sources.map(source => source.teamId)).size > 1)
+        throw new Error("READ_CONVERSATION_TEAM_MISMATCH");
+    return sources.reduce((total, source) => {
+        const unread = unreadInThread(state, source.id);
+        return { unreadMessageCount: total.unreadMessageCount + unread.unreadMessageCount, unreadMentionCount: total.unreadMentionCount + unread.unreadMentionCount, badgeCount: total.badgeCount + unread.badgeCount };
+    }, { unreadMessageCount: 0, unreadMentionCount: 0, badgeCount: 0 });
+}

package/lib/runtime/readSync.js

@@ -47,7 +47,19 @@ export class ReadSyncClient {
     async run() {
         const { appId, profileId, persistence } = this.options;
         const current = await this.loadLocal();
+        // Ordinary reads are monotonic: only the furthest position per thread needs
+        // sending. Keep every original operation in storage until the projection
+        // confirms it, and never rewrite an operation ID's payload during retries.
+        const latest = new Map();
         for (const operation of current.pending) {
+            if (operation.explicitReadMessageIds.length || operation.readThroughSeq <= 0)
+                continue;
+            const previous = latest.get(operation.threadId);
+            if (!previous || operation.readThroughSeq > previous.readThroughSeq)
+                latest.set(operation.threadId, operation);
+        }
+        const outgoing = current.pending.filter(operation => operation.explicitReadMessageIds.length || operation.readThroughSeq <= 0 || latest.get(operation.threadId) === operation);
+        for (const operation of outgoing) {
             const receipt = await this.request("/api/social/reading", {
                 method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ ...operation, appId, profileId }),
             });

package/lib/runtime/readerClient.d.ts

@@ -32,6 +32,7 @@ export type ChatReaderThread = {
     unread: number;
 };
 export type ChatReaderContact = {
+    teamId?: string;
     id?: string;
     accountId?: string;
     peerId?: string;
@@ -46,6 +47,8 @@ export type ChatReaderContact = {
     members?: string[];
 };
 export type ChatReaderSocialMessage = {
+    teamId?: string;
+    sourceThreadId?: string;
     appId: string;
     threadId: string;
     threadKind: "dm" | "group";
@@ -64,6 +67,7 @@ export type ChatReaderMessagePage = {
     data: ChatReaderMessage[];
 };
 export type ChatReaderUnread = {
+    teamId?: string;
     appId: string;
     accountId: string;
     threadId: string;

package/lib/runtime/teamMigrations.d.ts

@@ -0,0 +1,45 @@
+export type TeamAssignment = {
+    appId: string;
+    sourceThreadId: string;
+    threadId: string;
+    teamId: string;
+    actorId: string;
+    assignmentId: string;
+    createdAt: number;
+};
+export type TeamMigrationPlan = {
+    status: "assigned" | "noHistory" | "noCommonTeam" | "ready" | "needsSelection";
+    sourceThreadId: string;
+    candidates: {
+        id: string;
+        name: string;
+    }[];
+    messageCount?: number;
+    assignment?: TeamAssignment;
+};
+export type TeamMigrationResult = {
+    status: "assigned";
+    assignment: TeamAssignment;
+} | {
+    status: "pending";
+    sourceThreadId: string;
+};
+export declare class TeamMigrationError extends Error {
+    readonly status: number;
+    readonly assignment?: TeamAssignment | undefined;
+    constructor(status: number, message: string, assignment?: TeamAssignment | undefined);
+}
+/** Planning does not mutate history. Assignment uses the server's current membership and winner. */
+export declare class TeamMigrationClient {
+    private readonly options;
+    constructor(options: {
+        appId: string;
+        profileId: string;
+        token: string;
+        hubHttpUrl?: string;
+        fetch?: typeof fetch;
+    });
+    plan(peerId: string): Promise<TeamMigrationPlan>;
+    assign(peerId: string, teamId: string): Promise<TeamMigrationResult>;
+    private request;
+}

package/lib/runtime/teamMigrations.js

@@ -0,0 +1,32 @@
+export class TeamMigrationError extends Error {
+    status;
+    assignment;
+    constructor(status, message, assignment) {
+        super(message);
+        this.status = status;
+        this.assignment = assignment;
+    }
+}
+/** Planning does not mutate history. Assignment uses the server's current membership and winner. */
+export class TeamMigrationClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async plan(peerId) {
+        const query = new URLSearchParams({ appId: this.options.appId, profileId: this.options.profileId, peerId });
+        return this.request(`/plan?${query}`);
+    }
+    async assign(peerId, teamId) {
+        return this.request("", { method: "POST", body: JSON.stringify({ appId: this.options.appId, profileId: this.options.profileId, peerId, teamId }) });
+    }
+    async request(path, init = {}) {
+        const response = await (this.options.fetch ?? fetch)(`${(this.options.hubHttpUrl ?? "https://hub.pmate.chat").replace(/\/$/, "")}/api/social/team-migrations${path}`, {
+            ...init, signal: AbortSignal.timeout(15_000), headers: { "content-type": "application/json", authorization: `Bearer ${this.options.token}` }, redirect: "error",
+        });
+        const envelope = await response.json();
+        if (!response.ok || envelope.success !== true || envelope.data === undefined)
+            throw new TeamMigrationError(response.status, envelope.message ?? "TEAM_MIGRATION_FAILED", envelope.data?.assignment);
+        return envelope.data;
+    }
+}

package/lib/runtime/teamScope.d.ts

@@ -0,0 +1,5 @@
+import type { ChatBody } from "./protocol.js";
+/** Missing scope identifies legacy data; malformed scope must never become legacy. */
+export declare function chatTeamId(body: unknown): string | undefined;
+/** Preserve a message's scope and reject accidental sends into another active team. */
+export declare function withChatTeam(body: ChatBody, teamId?: string): ChatBody;

package/lib/runtime/teamScope.js

@@ -0,0 +1,53 @@
+import { isValidChatTeamId } from "./thread.js";
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function metadata(body) {
+    const value = record(body);
+    switch (value?.kind) {
+        case "message":
+        case "pending":
+        case "edit": return record(value.content);
+        case "quote": return record(record(value.content)?.content);
+        case "contact":
+        case "group":
+        case "hello": return record(value.payload);
+        case "activity":
+        case "recall":
+        case "delete": return value;
+        default: return undefined;
+    }
+}
+/** Missing scope identifies legacy data; malformed scope must never become legacy. */
+export function chatTeamId(body) {
+    const value = metadata(body);
+    if (!value || !("teamId" in value))
+        return undefined;
+    if (!isValidChatTeamId(value.teamId))
+        throw new Error("Invalid chat teamId");
+    return value.teamId;
+}
+/** Preserve a message's scope and reject accidental sends into another active team. */
+export function withChatTeam(body, teamId) {
+    const previous = chatTeamId(body);
+    if (teamId === undefined)
+        return body;
+    if (!isValidChatTeamId(teamId))
+        throw new Error("Invalid chat teamId");
+    if (previous !== undefined && previous !== teamId)
+        throw new Error("Chat teamId does not match the active team");
+    const scoped = { ...metadata(body), teamId };
+    switch (body.kind) {
+        case "message":
+        case "pending":
+        case "edit": return { ...body, content: scoped };
+        case "quote": return { ...body, content: { ...body.content, content: scoped } };
+        case "contact":
+        case "group":
+        case "hello": return { ...body, payload: scoped };
+        case "activity": return { ...body, teamId };
+        // Rust's legacy recall/delete bodies do not carry scope. Current clients use
+        // durable message content for recalls; fail explicitly until these upgrade.
+        default: throw new Error(`Team-scoped ${body.kind} is not supported`);
+    }
+}

package/lib/runtime/thread.d.ts

@@ -1,3 +1,4 @@
-export declare function pairId(appId: string, userA: string, userB: string): string;
-export declare function dmThreadId(appId: string, userA: string, userB: string): string;
-export declare function groupThreadId(appId: string, groupId: string): string;
+export declare function pairId(appId: string, userA: string, userB: string, teamId?: string): string;
+export declare function dmThreadId(appId: string, userA: string, userB: string, teamId?: string): string;
+export declare function groupThreadId(appId: string, groupId: string, teamId?: string): string;
+export declare function isValidChatTeamId(value: unknown): value is string;

package/lib/runtime/thread.js

@@ -1,15 +1,32 @@
 import { blake3 } from "@noble/hashes/blake3.js";
 import { bytesToHex } from "@noble/hashes/utils.js";
-export function pairId(appId, userA, userB) {
+export function pairId(appId, userA, userB, teamId) {
     const [left, right] = userA <= userB ? [userA, userB] : [userB, userA];
-    return stableHash(`social:v1:pair:${appId}:${left}:${right}`);
+    return teamId === undefined
+        ? stableHash(`social:v1:pair:${appId}:${left}:${right}`)
+        : teamThreadHash("pair", [appId, teamId, left, right]);
 }
-export function dmThreadId(appId, userA, userB) {
-    return stableHash(`social:v1:dm:${appId}:${pairId(appId, userA, userB)}`);
+export function dmThreadId(appId, userA, userB, teamId) {
+    return teamId === undefined
+        ? stableHash(`social:v1:dm:${appId}:${pairId(appId, userA, userB)}`)
+        : teamThreadHash("dm", [appId, teamId, pairId(appId, userA, userB)]);
 }
-export function groupThreadId(appId, groupId) {
-    return stableHash(`social:v1:group:${appId}:${groupId}`);
+export function groupThreadId(appId, groupId, teamId) {
+    return teamId === undefined
+        ? stableHash(`social:v1:group:${appId}:${groupId}`)
+        : teamThreadHash("group", [appId, teamId, groupId]);
+}
+/** JSON tuples avoid ambiguity when application/team IDs contain separators. */
+function teamThreadHash(kind, parts) {
+    const teamId = parts[1];
+    if (!isValidChatTeamId(teamId)) {
+        throw new Error("Invalid chat teamId");
+    }
+    return stableHash(`social:v2:${kind}:${JSON.stringify(parts)}`);
 }
 function stableHash(value) {
     return bytesToHex(blake3(new TextEncoder().encode(value)));
 }
+export function isValidChatTeamId(value) {
+    return typeof value === "string" && value.length > 0 && new TextEncoder().encode(value).length <= 512 && !/[\u0000-\u001f\u007f-\u009f]/.test(value);
+}

package/package.json

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