@pmate/chat-sdk 0.9.2 → 0.9.3

package/README.md

@@ -40,3 +40,35 @@ A dropped socket (including a network change or a suspended laptop) previously r
 `client.watchConnection(handler)` immediately reports the current state and returns an unsubscribe function. States are `connecting`, `reconnecting`, `authenticating`, `connected`, `authentication_required`, and `closed`. Only `connected` means the Hub acknowledged authentication. A rejected authentication stops retries; supply a fresh login session using a new client. `close()` cancels retries, heartbeat timers and browser wake listeners.
 
 Messages sent without an acknowledgement are rejected on disconnect and are **not replayed**: delivery is uncertain, so automatic retries could duplicate them. Callers should preserve drafts, display a reconnecting state, and refresh message history after recovery. No durable offline outbox is provided. An initial `connect()` wait times out after 30 seconds, but recovery continues until explicitly closed; retain the client and observe its connection state.
+
+## Versioned Markdown and chart content
+
+### Background
+
+A reply may need ordered prose, a trend chart, and a conclusion. The shared
+content contract carries those blocks inside the existing `contentKind: "text"`
+envelope. `text` is a deterministic projection for older clients and search;
+new clients render only explicitly versioned content, never guess Markdown.
+
+```ts
+import { createRichMessageContent, readMessageContent } from "@pmate/chat-sdk/runtime"
+const content = createRichMessageContent([
+  { id: "intro", type: "markdown", text: "## Analysis\n\n**Summary**" },
+])
+// sendChat(peer, { kind: "message", threadKind: "dm", contentKind: "text",
+//   content: { ...content, appId } })
+const result = readMessageContent(content)
+```
+
+`ChartBlock` supports line/bar, numeric series, `null` gaps and an evidence record
+(window, timezone, definition, source, query ID and completeness). Never fill
+missing coverage with zero or sum daily UV for a window total. HTML/scripts are
+not part of this protocol. Consumers must restrict URL schemes and render with
+safe Markdown components. Limits are 64 KiB, 20 blocks, 16,000 projection
+characters, 100 points and four series per chart. Invalid versions or content
+are explicit errors.
+
+`applyContentUpdate` accepts sequential revisions, ignores duplicate revisions,
+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.

package/lib/runtime/chatClient.d.ts

@@ -1,3 +1,4 @@
+import { type OnlineNotificationHandler } from "./notification.js";
 import { type ChatPresence } from "./presence.js";
 import { type ChatUpdate } from "./updates.js";
 import { ChatActivityPublisher, type ActivityTarget, type ChatActivity, type ChatActivityState, type ChatActivityUpdate } from "./activity.js";
@@ -8,6 +9,8 @@ import { type ChatBody, type ChatRuntimeMessage, type RealtimeClient } from "./p
 export type ChatConnectionState = "connecting" | "reconnecting" | "authenticating" | "connected" | "authentication_required" | "closed";
 export type ChatClientOptions = {
     appId: string;
+    clientInstanceId?: string;
+    onNotification?: OnlineNotificationHandler;
     profileId?: string;
     botKey?: PmateBotKeyFile | string | unknown;
     session?: BotLoginSession;
@@ -24,6 +27,7 @@ export type ChatClientOptions = {
 export declare class ChatClient {
     private readonly options;
     private readonly instanceId;
+    private readonly notifications;
     private presence?;
     private presenceProfiles;
     private presenceHandlers;

package/lib/runtime/chatClient.js

@@ -1,3 +1,4 @@
+import { OnlineNotificationReceiver } from "./notification.js";
 import { ChatPresenceClient } from "./presence.js";
 import { parseChatUpdate } from "./updates.js";
 import { ChatActivityStore, ChatActivityPublisher, createActivityMessage, parseChatActivity } from "./activity.js";
@@ -9,7 +10,8 @@ const DEFAULT_AUTH_API_BASE_URL = "https://auth-api-v2.pmate.chat";
 const DEFAULT_ACK_TIMEOUT_MS = 5_000;
 export class ChatClient {
     options;
-    instanceId = crypto.randomUUID();
+    instanceId;
+    notifications;
     presence;
     presenceProfiles = [];
     presenceHandlers = new Set();
@@ -33,6 +35,9 @@ export class ChatClient {
     }
     constructor(options) {
         this.options = options;
+        this.instanceId = options.clientInstanceId ?? crypto.randomUUID();
+        this.notifications = new OnlineNotificationReceiver({ appId: options.appId, profileId: () => this.profileId(),
+            send: message => this.requireClient().sendMsg(message), handler: options.onNotification });
         if (options.botKey) {
             this.botKey = parsePmateBotKeyJson(options.botKey);
         }
@@ -294,6 +299,11 @@ export class ChatClient {
         return ack;
     }
     handleIncoming(message) {
+        if (message.opcode === ChatMsgOp.NOTIFICATION) {
+            if (this.connection === "connected")
+                void this.notifications.receive(message).catch(error => this.options.onActivityError?.(error));
+            return;
+        }
         const update = parseChatUpdate(message, this.options.appId);
         if (update) {
             for (const handler of this.updateHandlers)

package/lib/runtime/index.d.ts

@@ -4,6 +4,7 @@ export * from "./chatClient.js";
 export * from "./protocol.js";
 export * from "./content.js";
 export * from "./readerClient.js";
+export * from "./readIndex.js";
 export * from "./thread.js";
 export * from "./updater.js";
 export * from "./updates.js";
@@ -11,3 +12,4 @@ export * from "./activity.js";
 export * from "./call.js";
 export * from "./presence.js";
 export * from "./meeting.js";
+export * from "./notification.js";

package/lib/runtime/index.js

@@ -4,6 +4,7 @@ export * from "./chatClient.js";
 export * from "./protocol.js";
 export * from "./content.js";
 export * from "./readerClient.js";
+export * from "./readIndex.js";
 export * from "./thread.js";
 export * from "./updater.js";
 export * from "./updates.js";
@@ -11,3 +12,4 @@ export * from "./activity.js";
 export * from "./call.js";
 export * from "./presence.js";
 export * from "./meeting.js";
+export * from "./notification.js";

package/lib/runtime/notification.d.ts

@@ -0,0 +1,28 @@
+import { type ChatRuntimeMessage } from "./protocol.js";
+export type OnlineNotification = {
+    kind: "delivery";
+    attemptId: string;
+    notificationId: string;
+    title?: string;
+    body?: string;
+    data: Record<string, unknown>;
+    createdAtMs?: number;
+    expiresAtMs?: number;
+};
+export type NotificationHandling = "displayed" | "suppressed";
+export type OnlineNotificationHandler = (notification: OnlineNotification) => Promise<NotificationHandling>;
+/** Device-local receipt and deduplication; only the host can confirm presentation. */
+export declare class OnlineNotificationReceiver {
+    private readonly options;
+    private readonly handled;
+    private readonly pending;
+    constructor(options: {
+        appId: string;
+        profileId: () => string;
+        send: (message: ChatRuntimeMessage) => Promise<void>;
+        handler?: OnlineNotificationHandler;
+        now?: () => number;
+    });
+    receive(message: ChatRuntimeMessage): Promise<void>;
+    private now;
+}

package/lib/runtime/notification.js

@@ -0,0 +1,68 @@
+import { ChatMsgOp, createRuntimeMsg } from "./protocol.js";
+/** Device-local receipt and deduplication; only the host can confirm presentation. */
+export class OnlineNotificationReceiver {
+    options;
+    handled = new Map();
+    pending = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async receive(message) {
+        if (message.opcode !== ChatMsgOp.NOTIFICATION || message.from !== "@hub/notifications" || message.to !== this.options.profileId())
+            return;
+        const body = message.body;
+        if (!body || body.kind !== "delivery" || typeof body.attemptId !== "string" || !body.attemptId
+            || typeof body.notificationId !== "string" || !body.notificationId)
+            return;
+        const ack = (status, code) => this.options.send(createRuntimeMsg(this.options.profileId(), "@hub/notifications", ChatMsgOp.NOTIFICATION, {
+            kind: "ack", attemptId: body.attemptId, notificationId: body.notificationId, status,
+            displayed: status === "displayed", code, receivedAtMs: this.now(),
+        }));
+        if (!body.data || typeof body.data !== "object" || body.data.appId !== this.options.appId) {
+            await ack("error", "notification_app_mismatch");
+            return;
+        }
+        if (body.expiresAtMs !== undefined && (!Number.isFinite(body.expiresAtMs) || body.expiresAtMs <= this.now())) {
+            await ack("suppressed", "notification_expired");
+            return;
+        }
+        if ((body.title !== undefined && typeof body.title !== "string") || (body.body !== undefined && typeof body.body !== "string")) {
+            await ack("error", "notification_invalid");
+            return;
+        }
+        await ack("received");
+        for (const [id, until] of this.handled)
+            if (until <= this.now())
+                this.handled.delete(id);
+        if (this.handled.has(body.notificationId)) {
+            await ack("suppressed", "notification_duplicate");
+            return;
+        }
+        let operation = this.pending.get(body.notificationId);
+        if (!operation) {
+            operation = Promise.resolve().then(async () => {
+                if (!this.options.handler)
+                    throw new Error("Notification host unavailable");
+                const status = await this.options.handler(structuredClone(body));
+                if (status !== "displayed" && status !== "suppressed")
+                    throw new Error("Invalid notification handling result");
+                if (this.handled.size >= 10_000)
+                    this.handled.delete(this.handled.keys().next().value);
+                this.handled.set(body.notificationId, Math.max(this.now() + 120_000, Math.min(body.expiresAtMs ?? this.now() + 86_400_000, this.now() + 86_400_000)));
+                return status;
+            });
+            this.pending.set(body.notificationId, operation);
+        }
+        try {
+            await ack(await operation);
+        }
+        catch {
+            await ack("error", "notification_handling_failed");
+        }
+        finally {
+            if (this.pending.get(body.notificationId) === operation)
+                this.pending.delete(body.notificationId);
+        }
+    }
+    now() { return this.options.now?.() ?? Date.now(); }
+}

package/lib/runtime/protocol.d.ts

@@ -3,6 +3,7 @@ export declare const ChatMsgOp: {
     readonly CHAT: 1;
     readonly ACK: 3;
     readonly AUTH: 4;
+    readonly NOTIFICATION: 5;
 };
 export declare const ChatMsgKind: {
     readonly DM: 1;

package/lib/runtime/protocol.js

@@ -3,6 +3,7 @@ export const ChatMsgOp = {
     CHAT: 1,
     ACK: 3,
     AUTH: 4,
+    NOTIFICATION: 5,
 };
 export const ChatMsgKind = {
     DM: 1,

package/lib/runtime/readIndex.d.ts

@@ -0,0 +1,78 @@
+/** Versioned, persistable reading projection shared by offline hosts. */
+export type IndexedReadMessage = {
+    id: string;
+    seq: number;
+    from: string;
+    recipients: string[];
+    mentions: string[];
+    readPolicy: "visible" | "explicit";
+    recalled: boolean;
+    /** Cached payload is retained so an offline reload can render the message. */
+    payload: unknown;
+};
+export type ReadingOperation = {
+    operationId: string;
+    threadId: string;
+    readThroughSeq: number;
+    readThroughMessageId?: string;
+    explicitReadMessageIds: string[];
+};
+export type IndexedReadThread = {
+    id: string;
+    kind: "dm" | "group";
+    messages: IndexedReadMessage[];
+    readThroughSeq: number;
+    explicitReadMessageIds: string[];
+};
+export type ReadIndexState = {
+    schemaVersion: 1;
+    appId: string;
+    profileId: string;
+    syncCursor: string;
+    threads: IndexedReadThread[];
+    pending: ReadingOperation[];
+};
+export type ReadSnapshot = Omit<ReadIndexState, "pending">;
+export type ReadChange = {
+    eventId: string;
+    appId: string;
+    profileId: string;
+    previousCursor: string;
+    syncCursor: string;
+    thread: IndexedReadThread;
+};
+export declare class ReadSyncGap extends Error {
+    readonly cursor: string;
+    constructor(cursor: string);
+}
+export declare function createReadIndex(appId: string, profileId: string): ReadIndexState;
+/** A snapshot is authoritative for server state, never for unsent local operations. */
+export declare function installReadSnapshot(current: ReadIndexState, snapshot: ReadSnapshot): ReadIndexState;
+/** Cursor positions are opaque; only exact predecessor matching proves continuity. */
+export declare function applyReadChange(current: ReadIndexState, change: ReadChange): 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;
+/** Coalescing does not mutate outbox IDs: remove operations only after projection confirms them. */
+export declare function coalesceReadOperations(current: ReadIndexState): (ReadingOperation & {
+    operationIds: string[];
+})[];
+/** Counts are over the indexed message coverage, not an estimate of missing history. */
+export declare function unreadInThread(state: ReadIndexState, threadId: string): {
+    unreadMessageCount: number;
+    unreadMentionCount: number;
+    badgeCount: number;
+};
+export interface ReadIndexPersistence {
+    load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
+    /** Transform and persist atomically; UI publishes only the committed result. */
+    update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
+}
+/** IndexedDB transactions serialize tabs, and retain offline outbox across process restarts. */
+export declare class IndexedDbReadIndex implements ReadIndexPersistence {
+    private readonly database;
+    constructor(factory?: IDBFactory, name?: string);
+    load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
+    update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
+    close(): Promise<void>;
+}

package/lib/runtime/readIndex.js

@@ -0,0 +1,180 @@
+export class ReadSyncGap extends Error {
+    cursor;
+    constructor(cursor) {
+        super("READ_SYNC_GAP");
+        this.cursor = cursor;
+    }
+}
+export function createReadIndex(appId, profileId) {
+    return { schemaVersion: 1, appId, profileId, syncCursor: "0", threads: [], pending: [] };
+}
+function validateThread(thread) {
+    if (!thread.id || !["dm", "group"].includes(thread.kind) || !Number.isSafeInteger(thread.readThroughSeq) || thread.readThroughSeq < 0)
+        throw new Error("INVALID_READ_THREAD");
+    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)
+            || !["visible", "explicit"].includes(message.readPolicy))
+            throw new Error("INVALID_READ_MESSAGE");
+        ids.add(message.id);
+        positions.add(message.seq);
+    }
+}
+function cloneThread(thread) {
+    validateThread(thread);
+    return structuredClone({ ...thread, messages: [...thread.messages].sort((a, b) => a.seq - b.seq), explicitReadMessageIds: [...new Set(thread.explicitReadMessageIds)] });
+}
+function applyOperation(thread, operation) {
+    return { ...thread, readThroughSeq: Math.max(thread.readThroughSeq, operation.readThroughSeq),
+        explicitReadMessageIds: [...new Set([...thread.explicitReadMessageIds, ...operation.explicitReadMessageIds])] };
+}
+function covered(thread, operation) {
+    return thread.readThroughSeq >= operation.readThroughSeq
+        && operation.explicitReadMessageIds.every(id => thread.explicitReadMessageIds.includes(id));
+}
+/** A snapshot is authoritative for server state, never for unsent local operations. */
+export function installReadSnapshot(current, snapshot) {
+    if (snapshot.schemaVersion !== 1 || snapshot.appId !== current.appId || snapshot.profileId !== current.profileId)
+        throw new Error("READ_IDENTITY_MISMATCH");
+    const threads = snapshot.threads.map(cloneThread);
+    if (new Set(threads.map(t => t.id)).size !== threads.length)
+        throw new Error("DUPLICATE_READ_THREAD");
+    const byId = new Map(threads.map(thread => [thread.id, thread]));
+    // Keep orphaned operations as well: the server must reject inaccessible updates explicitly.
+    const pending = current.pending.filter(operation => {
+        const thread = byId.get(operation.threadId);
+        return !thread || !covered(thread, operation);
+    });
+    for (const operation of pending) {
+        const thread = byId.get(operation.threadId);
+        if (thread)
+            byId.set(thread.id, applyOperation(thread, operation));
+    }
+    for (const previous of current.threads) {
+        const thread = byId.get(previous.id);
+        if (thread)
+            byId.set(thread.id, { ...thread, readThroughSeq: Math.max(thread.readThroughSeq, previous.readThroughSeq),
+                explicitReadMessageIds: [...new Set([...thread.explicitReadMessageIds, ...previous.explicitReadMessageIds])] });
+    }
+    return { ...snapshot, threads: [...byId.values()], pending };
+}
+/** Cursor positions are opaque; only exact predecessor matching proves continuity. */
+export function applyReadChange(current, change) {
+    if (change.appId !== current.appId || change.profileId !== current.profileId)
+        throw new Error("READ_IDENTITY_MISMATCH");
+    if (change.syncCursor === current.syncCursor)
+        return current;
+    if (change.previousCursor !== current.syncCursor)
+        throw new ReadSyncGap(current.syncCursor);
+    const incoming = cloneThread(change.thread);
+    const pending = current.pending.filter(operation => operation.threadId !== incoming.id || !covered(incoming, operation));
+    const previous = current.threads.find(thread => thread.id === incoming.id);
+    const merged = previous ? { ...incoming, readThroughSeq: Math.max(incoming.readThroughSeq, previous.readThroughSeq),
+        explicitReadMessageIds: [...new Set([...incoming.explicitReadMessageIds, ...previous.explicitReadMessageIds])] } : incoming;
+    const projected = pending.filter(operation => operation.threadId === incoming.id).reduce(applyOperation, merged);
+    return { ...current, syncCursor: change.syncCursor, pending, threads: [...current.threads.filter(t => t.id !== incoming.id), projected] };
+}
+/** 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 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: [] });
+}
+export function recordExplicitRead(current, threadId, messageId, operationId) {
+    const thread = current.threads.find(t => t.id === threadId);
+    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] });
+}
+function enqueue(current, operation) {
+    if (!operation.operationId || current.pending.some(p => p.operationId === operation.operationId))
+        throw new Error("INVALID_READ_OPERATION_ID");
+    return { ...current, pending: [...current.pending, operation], threads: current.threads.map(thread => thread.id === operation.threadId ? applyOperation(thread, operation) : thread) };
+}
+/** Coalescing does not mutate outbox IDs: remove operations only after projection confirms them. */
+export function coalesceReadOperations(current) {
+    const batches = new Map();
+    for (const operation of current.pending) {
+        const batch = batches.get(operation.threadId);
+        if (!batch) {
+            batches.set(operation.threadId, { ...structuredClone(operation), operationIds: [operation.operationId] });
+            continue;
+        }
+        batch.operationIds.push(operation.operationId);
+        if (operation.readThroughSeq > batch.readThroughSeq) {
+            batch.readThroughSeq = operation.readThroughSeq;
+            batch.readThroughMessageId = operation.readThroughMessageId;
+        }
+        batch.explicitReadMessageIds = [...new Set([...batch.explicitReadMessageIds, ...operation.explicitReadMessageIds])];
+    }
+    return [...batches.values()];
+}
+/** Counts are over the indexed message coverage, not an estimate of missing history. */
+export function unreadInThread(state, threadId) {
+    const thread = state.threads.find(t => t.id === 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)
+        && (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;
+    return { unreadMessageCount, unreadMentionCount, badgeCount: thread.kind === "group" ? unreadMentionCount : unreadMessageCount };
+}
+/** IndexedDB transactions serialize tabs, and retain offline outbox across process restarts. */
+export class IndexedDbReadIndex {
+    database;
+    constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index") {
+        if (!factory)
+            throw new Error("READ_STORAGE_UNAVAILABLE");
+        this.database = new Promise((resolve, reject) => {
+            const request = factory.open(name, 1);
+            request.onupgradeneeded = () => { request.result.createObjectStore("profiles"); };
+            request.onsuccess = () => { request.result.onversionchange = () => request.result.close(); resolve(request.result); };
+            request.onerror = () => reject(request.error);
+            request.onblocked = () => reject(new Error("READ_STORAGE_BLOCKED"));
+        });
+    }
+    async load(appId, profileId) {
+        const database = await this.database;
+        return new Promise((resolve, reject) => {
+            const transaction = database.transaction("profiles", "readonly");
+            const request = transaction.objectStore("profiles").get([appId, profileId]);
+            transaction.oncomplete = () => resolve(request.result);
+            transaction.onerror = () => reject(transaction.error);
+            transaction.onabort = () => reject(transaction.error ?? new Error("READ_STORAGE_ABORTED"));
+        });
+    }
+    async update(appId, profileId, transform) {
+        const database = await this.database;
+        return new Promise((resolve, reject) => {
+            const transaction = database.transaction("profiles", "readwrite");
+            const store = transaction.objectStore("profiles");
+            const request = store.get([appId, profileId]);
+            let next, failure;
+            request.onsuccess = () => {
+                try {
+                    next = transform(request.result ?? createReadIndex(appId, profileId));
+                    if (next.appId !== appId || next.profileId !== profileId || next.schemaVersion !== 1)
+                        throw new Error("READ_IDENTITY_MISMATCH");
+                    store.put(next, [appId, profileId]);
+                }
+                catch (error) {
+                    failure = error;
+                    transaction.abort();
+                }
+            };
+            transaction.oncomplete = () => resolve(next);
+            transaction.onerror = () => reject(failure ?? transaction.error);
+            transaction.onabort = () => reject(failure ?? transaction.error ?? new Error("READ_STORAGE_ABORTED"));
+        });
+    }
+    async close() { (await this.database).close(); }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",
@@ -28,11 +28,20 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "clean": "rimraf lib",
+    "build": "pnpm run clean && tsc -p tsconfig.build.json && cp src/voice/recorder-processor.js lib/voice/recorder-processor.js",
+    "prepack": "pnpm run build",
+    "npm:publish": "pnpm run build && npm publish --access public --registry https://registry.npmjs.org/",
+    "test": "vitest run",
+    "storybook": "storybook dev -p 6009",
+    "build-storybook": "storybook build --output-dir dist"
+  },
   "dependencies": {
-    "@noble/hashes": "^2.4.0",
     "@emoji-mart/data": "^1.2.1",
     "@emoji-mart/react": "^1.1.1",
     "@msgpack/msgpack": "^3.1.2",
+    "@noble/hashes": "^2.4.0",
     "jotai": "^2.16.1"
   },
   "peerDependencies": {
@@ -42,23 +51,16 @@
   "devDependencies": {
     "@storybook/addon-docs": "^9.0.17",
     "@storybook/react-vite": "9.0.17",
-    "@tailwindcss/vite": "^4.1.3",
-    "@types/react": "^19.2.7",
-    "@types/react-dom": "^19.2.3",
-    "react": "^19.1.1",
-    "react-dom": "^19.1.1",
+    "@tailwindcss/vite": "catalog:",
+    "@types/react": "catalog:",
+    "@types/react-dom": "catalog:",
+    "fake-indexeddb": "^6.2.5",
+    "react": "catalog:",
+    "react-dom": "catalog:",
     "rimraf": "^6.1.2",
     "storybook": "^9.0.17",
-    "tailwindcss": "^4.0.14",
+    "tailwindcss": "catalog:",
     "typescript": "5.9.2",
     "vitest": "^4.0.17"
-  },
-  "scripts": {
-    "clean": "rimraf lib",
-    "build": "pnpm run clean && tsc -p tsconfig.build.json && cp src/voice/recorder-processor.js lib/voice/recorder-processor.js",
-    "npm:publish": "pnpm run build && npm publish --access public --registry https://registry.npmjs.org/",
-    "test": "vitest run",
-    "storybook": "storybook dev -p 6009",
-    "build-storybook": "storybook build --output-dir dist"
   }
-}
+}