@pmate/chat-sdk 0.11.9 → 0.12.0-next.1

package/lib/runtime/messageStore.js

@@ -0,0 +1,81 @@
+import { Dexie } from "dexie";
+export const messageScopeKey = (scope) => JSON.stringify([scope.appId, scope.accountId, scope.profileId, scope.teamId]);
+/** Normalized browser cache. Data and coverage advance together in each commit.
+ * Merge runs inside the write transaction against the latest cross-tab state. */
+export class IndexedDbMessageStore {
+    merge;
+    db;
+    rows;
+    coverage;
+    key;
+    constructor(scope, merge, options = {}) {
+        this.merge = merge;
+        this.key = messageScopeKey(scope);
+        this.db = new Dexie(options.name ?? "pmate-chat-messages", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
+        this.db.version(1).stores({ messages: "[scope+thread+id],[scope+thread+time+id],[scope+thread],scope", coverage: "[scope+thread],scope" });
+        this.rows = this.db.table("messages");
+        this.coverage = this.db.table("coverage");
+        this.db.on("versionchange", () => { this.db.close({ disableAutoOpen: false }); return false; });
+    }
+    async read(thread, limit = 100, before) {
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
+            throw new Error("INVALID_MESSAGE_LIMIT");
+        return this.db.transaction("r", this.rows, this.coverage, async () => {
+            const range = this.rows.where("[scope+thread+time+id]").between([this.key, thread, Dexie.minKey, Dexie.minKey], [this.key, thread, before?.timestamp ?? Dexie.maxKey, before?.id ?? Dexie.maxKey], true, !before);
+            const records = await range.reverse().limit(limit + 1).toArray();
+            return { messages: records.slice(0, limit).reverse().map(row => row.value), hasEarlier: records.length > limit, coverage: await this.coverage.get([this.key, thread]) };
+        });
+    }
+    async commit(thread, messages, coverage) {
+        for (const message of messages)
+            if (message.threadId !== thread || !message.id || !Number.isFinite(message.timestamp))
+                throw new Error("MESSAGE_SCOPE_MISMATCH");
+        if (messages.length > 1000)
+            throw new Error("MESSAGE_BATCH_TOO_LARGE");
+        return this.db.transaction("rw", this.rows, this.coverage, async () => {
+            const ids = [...new Set(messages.map(message => message.id))];
+            const previous = await this.rows.bulkGet(ids.map(id => [this.key, thread, id]));
+            const latest = new Map(previous.flatMap(row => row ? [[row.id, row.value]] : []));
+            const changed = new Map();
+            for (const message of messages) {
+                const old = latest.get(message.id), value = this.merge(old, message);
+                if (value.id !== message.id || value.threadId !== thread || !Number.isFinite(value.timestamp))
+                    throw new Error("MESSAGE_SCOPE_MISMATCH");
+                latest.set(message.id, value);
+                if (JSON.stringify(old) !== JSON.stringify(value))
+                    changed.set(message.id, { scope: this.key, thread, id: value.id, time: value.timestamp, value });
+            }
+            if (changed.size)
+                await this.rows.bulkPut([...changed.values()]);
+            if (coverage) {
+                const old = await this.coverage.get([this.key, thread]), next = { ...coverage, scope: this.key, thread };
+                if (JSON.stringify(old) !== JSON.stringify(next))
+                    await this.coverage.put(next);
+            }
+            return changed.size;
+        });
+    }
+    async removeThread(thread) {
+        await this.db.transaction("rw", this.rows, this.coverage, async () => {
+            await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();
+            await this.coverage.delete([this.key, thread]);
+        });
+    }
+    async clear() {
+        await this.db.transaction("rw", this.rows, this.coverage, async () => {
+            await this.rows.where("scope").equals(this.key).delete();
+            await this.coverage.where("scope").equals(this.key).delete();
+        });
+    }
+    close() { this.db.close(); }
+}
+/** Keep tombstones monotonic; applications can supply stricter domain reducers. */
+export function mergeStoredMessage(previous, incoming) {
+    if (!previous)
+        return incoming;
+    if (previous.recalled && !incoming.recalled)
+        return previous;
+    if ((previous.revision ?? 0) > (incoming.revision ?? 0))
+        return previous;
+    return incoming;
+}

package/lib/runtime/readIndex.js

@@ -102,8 +102,9 @@ function resolveObservedReads(current) {
         }
         if (message.recalled || message.from === next.profileId || !message.recipients.includes(next.profileId))
             continue;
+        // Visibility may include voice rows; incompatible observations never acknowledge them.
         if (message.readPolicy !== intent.readPolicy)
-            throw new Error("READ_POLICY_MISMATCH");
+            continue;
         next = intent.readPolicy === "explicit" ? recordExplicitRead(next, intent.threadId, intent.messageId, intent.operationId)
             : recordVisibleRead(next, intent.threadId, intent.messageId, intent.operationId);
     }
@@ -206,10 +207,12 @@ export class IndexedDbReadIndex {
     }
     async update(appId, profileId, transform) {
         return this.transaction("rw", async () => {
-            const next = transform(await this.profiles.get([appId, profileId]) ?? createReadIndex(appId, profileId));
+            const previous = await this.profiles.get([appId, profileId]);
+            const next = transform(previous ?? createReadIndex(appId, profileId));
             if (next.appId !== appId || next.profileId !== profileId || next.schemaVersion !== 1)
                 throw new Error("READ_IDENTITY_MISMATCH");
-            await this.profiles.put(next, [appId, profileId]);
+            if (JSON.stringify(next) !== JSON.stringify(previous))
+                await this.profiles.put(next, [appId, profileId]);
             return next;
         });
     }

package/lib/runtime/readingClient.d.ts

@@ -0,0 +1,40 @@
+import { type ReadIndexPersistence, type ReadIndexState } from "./readIndex.js";
+export type ReadingClientOptions = {
+    appId: string;
+    profileId: string;
+    sessionToken: string;
+    hubHttpUrl: string;
+    persistence?: ReadIndexPersistence;
+    fetch?: typeof fetch;
+    onError?: (error: unknown) => void;
+    onRecovered?: () => void;
+};
+/** Owns durable local reads, network coalescing, retries and state notifications.
+ * Hosts report actual visibility; loading or subscribing never marks messages read. */
+export declare class ReadingClient {
+    private options;
+    private storage;
+    private persistence;
+    private sync;
+    private tasks;
+    private listeners;
+    private state?;
+    private closed;
+    private retry?;
+    private retryDelay;
+    private offWake?;
+    private generation;
+    constructor(options: ReadingClientOptions);
+    getSnapshot: () => ReadIndexState | undefined;
+    subscribe: (listener: () => void) => () => void;
+    private publish;
+    private failed;
+    start(): Promise<void>;
+    refresh: () => void;
+    synchronize(targetCursor?: string, profileId?: string): Promise<ReadIndexState>;
+    update(transform: (state: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
+    recordVisible(threadId: string, messageIds: string[]): Promise<ReadIndexState>;
+    recordExplicit(threadId: string, messageIds: string[]): Promise<ReadIndexState>;
+    private record;
+    close(): Promise<void>;
+}

package/lib/runtime/readingClient.js

@@ -0,0 +1,115 @@
+import { BatchedReadIndex } from "./batchedReadIndex.js";
+import { WindowedTasks } from "./coalescer.js";
+import { IndexedDbReadIndex, recordReadIntent } from "./readIndex.js";
+import { ReadSyncClient } from "./readSync.js";
+/** Owns durable local reads, network coalescing, retries and state notifications.
+ * Hosts report actual visibility; loading or subscribing never marks messages read. */
+export class ReadingClient {
+    options;
+    storage;
+    persistence;
+    sync;
+    tasks;
+    listeners = new Set();
+    state;
+    closed = false;
+    retry;
+    retryDelay = 1000;
+    offWake;
+    generation = 0;
+    constructor(options) {
+        this.options = options;
+        const storage = options.persistence ?? (this.storage = new IndexedDbReadIndex());
+        this.persistence = new BatchedReadIndex(storage);
+        this.tasks = new WindowedTasks(1000, error => this.failed(error));
+        this.sync = new ReadSyncClient({ ...options, persistence: this.persistence, onChange: state => this.publish(state) });
+    }
+    getSnapshot = () => this.state;
+    subscribe = (listener) => { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; };
+    publish(state) {
+        if (this.closed || JSON.stringify(state) === JSON.stringify(this.state))
+            return;
+        this.state = state;
+        this.listeners.forEach(listener => listener());
+    }
+    failed(error) {
+        if (this.closed)
+            return;
+        this.options.onError?.(error);
+        if (/HTTP_(400|401|403)/.test(String(error)) || (typeof navigator !== "undefined" && !navigator.onLine) || this.retry)
+            return;
+        this.retry = setTimeout(() => { this.retry = undefined; this.refresh(); }, this.retryDelay);
+        this.retryDelay = Math.min(this.retryDelay * 2, 30_000);
+    }
+    async start() {
+        if (this.closed)
+            throw new Error("READING_CLIENT_CLOSED");
+        this.publish(await this.sync.loadLocal());
+        if (this.closed)
+            return;
+        if (typeof window !== "undefined" && !this.offWake) {
+            const wake = () => this.refresh();
+            window.addEventListener("online", wake);
+            window.addEventListener("focus", wake);
+            this.offWake = () => { window.removeEventListener("online", wake); window.removeEventListener("focus", wake); };
+        }
+        this.refresh();
+    }
+    refresh = () => {
+        if (!this.closed)
+            this.tasks.schedule("reading", async () => { await this.synchronize(); });
+    };
+    async synchronize(targetCursor, profileId) {
+        if (this.closed)
+            throw new Error("READING_CLIENT_CLOSED");
+        if (profileId !== undefined && profileId !== this.options.profileId)
+            throw new Error("Reading reach identity mismatch");
+        if (targetCursor !== undefined && !/^v1:\d+$/.test(targetCursor))
+            throw new Error("Invalid reading reach cursor");
+        const generation = this.generation;
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const next = await this.sync.synchronize();
+            if (this.closed || generation !== this.generation)
+                throw new Error("READING_CLIENT_CLOSED");
+            const cursor = /^(?:teams:[0-9a-f]{64}:)?v1:(\d+)$/.exec(next.syncCursor);
+            if (targetCursor === undefined || (cursor && BigInt(cursor[1]) >= BigInt(targetCursor.slice(3)))) {
+                clearTimeout(this.retry);
+                this.retry = undefined;
+                this.retryDelay = 1000;
+                this.options.onRecovered?.();
+                if (next.pending.length)
+                    this.refresh();
+                return next;
+            }
+        }
+        throw new Error("Reading projection has not reached the announced version");
+    }
+    async update(transform) {
+        if (this.closed)
+            throw new Error("READING_CLIENT_CLOSED");
+        const next = await this.persistence.update(this.options.appId, this.options.profileId, transform);
+        if (!this.closed) {
+            this.publish(next);
+            if (next.pending.length || next.observedReadIntents?.length)
+                this.refresh();
+        }
+        return next;
+    }
+    recordVisible(threadId, messageIds) { return this.record(threadId, messageIds, "visible"); }
+    recordExplicit(threadId, messageIds) { return this.record(threadId, messageIds, "explicit"); }
+    record(threadId, ids, readPolicy) {
+        const messageIds = [...new Set(ids)];
+        return this.update(state => messageIds.reduce((next, messageId) => recordReadIntent(next, { threadId, messageId, readPolicy, operationId: crypto.randomUUID() }), state));
+    }
+    async close() {
+        this.closed = true;
+        this.generation++;
+        this.offWake?.();
+        this.tasks.close();
+        clearTimeout(this.retry);
+        this.sync.stop();
+        this.listeners.clear();
+        await this.persistence.close();
+        await this.storage?.close();
+    }
+}

package/lib/runtime/recordCache.d.ts

@@ -0,0 +1,41 @@
+export type RecordCacheOptions<T> = {
+    scope: string;
+    key: (value: T) => string;
+    merge: (previous: T | undefined, incoming: T) => T;
+    indexedDB?: IDBFactory;
+    name?: string;
+    onError?: (error: unknown) => void;
+};
+/** In-memory control-event index backed by bounded asynchronous IndexedDB batches.
+ * Legacy storage is read only during open; the hot path never uses localStorage. */
+export declare class IndexedDbRecordCache<T> {
+    private options;
+    private db;
+    private records;
+    private metadata;
+    private values;
+    private snapshotValue;
+    private pending;
+    private waiters;
+    private tasks;
+    private ready?;
+    private closed;
+    private closing;
+    private initialized;
+    private running?;
+    private channel?;
+    private listeners;
+    constructor(options: RecordCacheOptions<T>);
+    open(legacy?: () => {
+        values: T[];
+        clear: () => void;
+    }): Promise<void>;
+    snapshot(): readonly T[];
+    subscribe(listener: () => void): () => void;
+    private reload;
+    upsert(incoming: T[]): Promise<void>;
+    private write;
+    flush(): Promise<void>;
+    private runFlush;
+    close(): Promise<void>;
+}

package/lib/runtime/recordCache.js

@@ -0,0 +1,163 @@
+import { Dexie } from "dexie";
+import { WindowedTasks } from "./coalescer.js";
+/** In-memory control-event index backed by bounded asynchronous IndexedDB batches.
+ * Legacy storage is read only during open; the hot path never uses localStorage. */
+export class IndexedDbRecordCache {
+    options;
+    db;
+    records;
+    metadata;
+    values = new Map();
+    snapshotValue = [];
+    pending = new Map();
+    waiters = [];
+    tasks;
+    ready;
+    closed = false;
+    closing = false;
+    initialized = false;
+    running;
+    channel;
+    listeners = new Set();
+    constructor(options) {
+        this.options = options;
+        this.db = new Dexie(options.name ?? "pmate-chat-records", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
+        this.db.version(1).stores({ records: "[scope+id],scope", metadata: "scope" });
+        this.records = this.db.table("records");
+        this.metadata = this.db.table("metadata");
+        this.tasks = new WindowedTasks(16, error => options.onError?.(error));
+        if (typeof BroadcastChannel !== "undefined") {
+            this.channel = new BroadcastChannel(`pmate-chat-records:${options.scope}`);
+            this.channel.onmessage = () => this.tasks.schedule("reload", () => this.reload());
+        }
+    }
+    open(legacy) {
+        if (this.closed)
+            return Promise.reject(new Error("RECORD_CACHE_CLOSED"));
+        if (this.ready)
+            return this.ready;
+        this.ready = (async () => {
+            if (legacy && !(await this.metadata.get(this.options.scope))?.migrated) {
+                const previous = legacy();
+                // Idempotent batches: the completion marker is written only after every row.
+                for (let offset = 0; offset < previous.values.length; offset += 128)
+                    await this.write(previous.values.slice(offset, offset + 128));
+                await this.metadata.put({ scope: this.options.scope, migrated: true });
+                previous.clear();
+            }
+            await this.reload();
+            this.initialized = true;
+            this.listeners.forEach(listener => listener());
+        })().catch(error => { this.ready = undefined; throw error; });
+        return this.ready;
+    }
+    snapshot() {
+        if (!this.initialized)
+            throw new Error("RECORD_CACHE_NOT_OPEN");
+        return this.snapshotValue;
+    }
+    subscribe(listener) { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }
+    async reload() {
+        const rows = await this.records.where("scope").equals(this.options.scope).toArray();
+        if (this.closed)
+            return;
+        let changed = false;
+        for (const row of rows) {
+            const old = this.values.get(row.id), next = this.options.merge(old, row.value);
+            if (JSON.stringify(old) !== JSON.stringify(next)) {
+                this.values.set(row.id, next);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.snapshotValue = [...this.values.values()];
+            if (this.initialized)
+                this.listeners.forEach(listener => listener());
+        }
+    }
+    async upsert(incoming) {
+        if (this.closed || this.closing)
+            throw new Error("RECORD_CACHE_CLOSED");
+        if (!this.ready)
+            throw new Error("RECORD_CACHE_NOT_OPEN");
+        await this.ready;
+        if (this.closed || this.closing)
+            throw new Error("RECORD_CACHE_CLOSED");
+        if (incoming.length + this.pending.size > 4096)
+            throw new Error("RECORD_CACHE_BACKPRESSURE");
+        let changed = false;
+        for (const value of incoming) {
+            const key = this.options.key(value), old = this.values.get(key), next = this.options.merge(old, value);
+            if (JSON.stringify(old) === JSON.stringify(next))
+                continue;
+            this.values.set(key, next);
+            this.pending.set(key, next);
+            changed = true;
+        }
+        if (changed)
+            this.snapshotValue = [...this.values.values()];
+        if (!changed && !this.pending.size)
+            return;
+        const committed = new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+        this.tasks.schedule("write", () => this.flush());
+        return committed;
+    }
+    async write(values) {
+        await this.db.transaction("rw", this.records, async () => {
+            const previous = await this.records.bulkGet(values.map(value => [this.options.scope, this.options.key(value)]));
+            const records = values.map((value, index) => ({ scope: this.options.scope, id: this.options.key(value), value: this.options.merge(previous[index]?.value, value) }));
+            const changed = records.filter((row, index) => JSON.stringify(previous[index]?.value) !== JSON.stringify(row.value));
+            if (changed.length)
+                await this.records.bulkPut(changed);
+        });
+    }
+    async flush() {
+        if (this.running) {
+            await this.running;
+            if (this.pending.size)
+                return this.flush();
+            return;
+        }
+        const task = this.runFlush().finally(() => { if (this.running === task)
+            this.running = undefined; });
+        this.running = task;
+        return task;
+    }
+    async runFlush() {
+        const values = [...this.pending.values()], waiters = this.waiters.splice(0);
+        this.pending.clear();
+        if (!values.length)
+            return;
+        try {
+            for (let offset = 0; offset < values.length; offset += 128)
+                await this.write(values.slice(offset, offset + 128));
+            await this.reload();
+            this.listeners.forEach(listener => listener());
+            this.channel?.postMessage("changed");
+            waiters.forEach(waiter => waiter.resolve());
+        }
+        catch (error) {
+            // Keep failed records dirty so a later operation can retry them.
+            for (const value of values) {
+                const key = this.options.key(value);
+                this.pending.set(key, this.options.merge(value, this.pending.get(key) ?? value));
+            }
+            waiters.forEach(waiter => waiter.reject(error));
+            throw error;
+        }
+    }
+    async close() {
+        this.closing = true;
+        await this.ready;
+        this.tasks.close();
+        try {
+            await this.flush();
+        }
+        finally {
+            this.closed = true;
+            this.channel?.close();
+            this.listeners.clear();
+            this.db.close();
+        }
+    }
+}

package/lib/runtime/socialReadClient.d.ts

@@ -6,6 +6,13 @@ export type SocialReadClientOptions = {
     hubHttpUrl?: string;
     fetch?: typeof fetch;
 };
+export type SocialMessagePage = {
+    messages: ChatReaderSocialMessage[];
+    checkpoint: string;
+    nextBefore: string | null;
+    hasMoreChanges: boolean;
+    resetRequired: boolean;
+};
 export type SocialGroup = {
     appId: string;
     groupId: string;
@@ -44,6 +51,13 @@ export declare class SocialReadClient {
         threadId: string;
         teamId?: string;
     }): Promise<ChatReaderSocialMessage[]>;
+    messagePage(input: {
+        threadId: string;
+        teamId?: string;
+        limit?: number;
+        before?: string;
+        after?: string;
+    }, signal?: AbortSignal): Promise<SocialMessagePage>;
     group(input: {
         groupId: string;
         teamId?: string;

package/lib/runtime/socialReadClient.js

@@ -24,6 +24,21 @@ export class SocialReadClient {
         this.requireTeam(input.teamId);
         return this.list("messages", { threadId: input.threadId, ...this.teamQuery(input.teamId) });
     }
+    async messagePage(input, signal) {
+        this.requireTeam(input.teamId);
+        const limit = input.limit ?? 100;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500 || (input.before !== undefined && input.after !== undefined))
+            throw new SocialReadError(400, "INVALID_MESSAGE_PAGE");
+        const value = await this.request("messages", { threadId: input.threadId, ...this.teamQuery(input.teamId), limit: String(limit),
+            ...(input.before === undefined ? {} : { before: input.before }), ...(input.after === undefined ? {} : { after: input.after }) }, signal);
+        const cursor = (token) => typeof token === "string" && /^mp1:\d+:[0-9a-f]{64}$/.test(token);
+        if (!value || !Array.isArray(value.messages) || value.messages.length > limit || !cursor(value.checkpoint)
+            || (value.nextBefore !== null && !cursor(value.nextBefore)) || typeof value.hasMoreChanges !== "boolean" || typeof value.resetRequired !== "boolean"
+            || value.messages.some(row => row.appId !== this.options.appId || row.threadId !== input.threadId || row.teamId !== input.teamId || !row.messageId || !Number.isFinite(row.serverCreatedAt))
+            || (value.resetRequired && (value.messages.length || value.hasMoreChanges || value.nextBefore !== null)))
+            throw new SocialReadError(502, "INVALID_MESSAGE_PAGE_RESPONSE");
+        return value;
+    }
     group(input) {
         this.requireTeam(input.teamId);
         return this.request("group", { groupId: input.groupId, ...this.teamQuery(input.teamId) });
@@ -45,11 +60,11 @@ export class SocialReadClient {
             throw new SocialReadError(502, "INVALID_SOCIAL_READ_RESPONSE");
         return value;
     }
-    async request(action, query) {
+    async request(action, query, signal) {
         const search = new URLSearchParams({ ...query, appId: this.options.appId, profileId: this.options.profileId });
         const result = await (this.options.fetch ?? fetch)(`${(this.options.hubHttpUrl ?? "https://hub.pmate.chat").replace(/\/+$/, "")}/api/social/${action}?${search}`, {
             headers: { authorization: `Bearer ${this.options.token}`, accept: "application/json" },
-            cache: "no-store", redirect: "error", signal: AbortSignal.timeout(15_000),
+            cache: "no-store", redirect: "error", signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(15_000)]) : AbortSignal.timeout(15_000),
         });
         const envelope = await result.json().catch(() => null);
         if (!result.ok || envelope?.success !== true || !Object.hasOwn(envelope, "data")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.11.9",
+  "version": "0.12.0-next.1",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",
@@ -28,15 +28,6 @@
   "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": {
     "@emoji-mart/data": "^1.2.1",
     "@emoji-mart/react": "^1.1.1",
@@ -52,16 +43,24 @@
   "devDependencies": {
     "@storybook/addon-docs": "^9.0.17",
     "@storybook/react-vite": "9.0.17",
-    "@tailwindcss/vite": "catalog:",
-    "@types/react": "catalog:",
-    "@types/react-dom": "catalog:",
+    "@tailwindcss/vite": "^4.1.3",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
     "fake-indexeddb": "^6.2.5",
-    "react": "catalog:",
-    "react-dom": "catalog:",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
     "rimraf": "^6.1.2",
     "storybook": "^9.0.17",
-    "tailwindcss": "catalog:",
+    "tailwindcss": "^4.0.14",
     "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"
   }
-}
+}