@secrecy/lib 1.86.0 → 1.86.1-feat-improve-sdk.2

package/dist/lib/base-client.js

@@ -1,4 +1,4 @@
-import { usersCache } from './cache.js';
+import { usersCache, clearAllCaches } from './cache.js';
 import { getStorage } from './client/storage.js';
 import { createTRPCClient, } from './client.js';
 import { getPreferedEmail } from './utils.js';
@@ -46,15 +46,16 @@ export class BaseClient {
                 BaseClient.getBaseClient({
                     session: opts.session,
                     apiUrl: this.secrecyUrls.api,
+                    timeoutMs: opts.timeoutMs,
                     onAccessDenied: async () => {
-                        console.log('[BASE_CLIENT - BEFORE] - Access denied');
                         await opts.onAccessDenied?.();
-                        console.log('[BASE_CLIENT - AFTER] - Access denied');
                         try {
                             await this.logout();
                         }
                         finally {
-                            location.reload();
+                            if (opts.reloadOnAccessDenied ?? true) {
+                                location.reload();
+                            }
                         }
                     },
                 });
@@ -141,6 +142,6 @@ export class BaseClient {
         session.identities.clear();
         session.keyPairs.clear();
         session.userAppSession.clear();
-        usersCache.clear();
+        clearAllCaches();
     };
 }

package/dist/lib/cache.js

@@ -1,8 +1,9 @@
 import { LRUCache } from 'lru-cache';
 import { gigaToBytes } from './utils.js';
-export const dataCache = new Map();
-export const nodesCache = new Map();
-export const nodesEncryptionCache = new Map();
+const boundedCacheOpts = { max: 5_000, ttl: 5 * 60 * 1000 };
+export const dataCache = new LRUCache(boundedCacheOpts);
+export const nodesCache = new LRUCache(boundedCacheOpts);
+export const nodesEncryptionCache = new LRUCache(boundedCacheOpts);
 export const getNodeForEncryptionFromCache = (id) => {
     if (nodesEncryptionCache.has(id)) {
         return nodesEncryptionCache.get(id);
@@ -12,8 +13,8 @@ export const getNodeForEncryptionFromCache = (id) => {
     }
     return undefined;
 };
-export const usersCache = new Map();
-export const publicKeysCache = new Map();
+export const usersCache = new LRUCache(boundedCacheOpts);
+export const publicKeysCache = new LRUCache({ max: 10_000 });
 export const dataContentCache = new LRUCache({
     max: 500,
     maxSize: gigaToBytes(0.5),
@@ -21,3 +22,11 @@ export const dataContentCache = new LRUCache({
         return value.data.byteLength;
     },
 });
+export function clearAllCaches() {
+    dataCache.clear();
+    nodesCache.clear();
+    nodesEncryptionCache.clear();
+    usersCache.clear();
+    publicKeysCache.clear();
+    dataContentCache.clear();
+}

package/dist/lib/client/SecrecyMailClient.js

@@ -31,8 +31,13 @@ export class SecrecyMailClient {
         })));
     }
     async create(data, customMessage) {
-        const mail = await this.createDraft(data);
-        const isSent = await this.sendDraft(mail.mailIntegrityId, customMessage);
+        const { customMessage: embeddedCustomMessage, ...mailData } = data;
+        const resolvedCustomMessage = customMessage ?? embeddedCustomMessage;
+        const mail = await this.createDraft(mailData);
+        const isSent = await this.sendDraft({
+            draftId: mail.mailIntegrityId,
+            customMessage: resolvedCustomMessage,
+        });
         if (!isSent) {
             throw new Error('The mail does not sent!');
         }
@@ -53,7 +58,8 @@ export class SecrecyMailClient {
         }));
         return waitingReceivedMailsWithIds;
     }
-    async updateDraft(draftId, { body, subject, senderFiles, recipients, replyToId }) {
+    async updateDraft(arg, args) {
+        const { draftId, body, subject, senderFiles, recipients, replyToId, } = typeof arg === 'string' ? { draftId: arg, ...args } : arg;
         const drafts = await this.draftMails({});
         const draft = drafts.find((d) => d.mailIntegrityId === draftId);
         if (draft === undefined) {
@@ -124,7 +130,8 @@ export class SecrecyMailClient {
         });
         return isDeleted;
     }
-    async sendDraft(draftId, customMessage) {
+    async sendDraft(arg, customMessage) {
+        const { draftId, customMessage: resolvedCustomMessage } = typeof arg === 'string' ? { draftId: arg, customMessage } : arg;
         const drafts = await this.draftMails({});
         const draft = drafts.find((d) => d.mailIntegrityId === draftId);
         if (draft === undefined) {
@@ -157,7 +164,7 @@ export class SecrecyMailClient {
             temporaryRecipients,
             recipients,
             id: draft.mailIntegrityId,
-            customMessage: customMessage ?? null,
+            customMessage: resolvedCustomMessage ?? null,
         });
         return isSent;
     }

package/dist/lib/client/helpers.js

@@ -2,14 +2,26 @@ import { SecrecyClient } from './index.js';
 import { popup } from '../utils/popup-tools.js';
 import { secrecyUserApp } from './types/index.js';
 import { getStorage } from './storage.js';
+import { setup } from '../sodium.js';
+export function assertBrowser(fn) {
+    if (typeof window === 'undefined') {
+        const err = {
+            name: 'ClientError',
+            code: 'SERVER_ENVIRONMENT',
+            message: `${fn}() can only run in a browser. On Next.js, call it from a "use client" component, or via dynamic(..., { ssr: false }).`,
+        };
+        throw err;
+    }
+}
 export function parseInfos() {
+    assertBrowser('parseInfos');
     if (window.location.hash === '') {
         return null;
     }
-    const hash = window.location.hash.substr(1);
+    const hash = window.location.hash.slice(1);
     try {
         const res = JSON.parse(atob(hash));
-        window.location.hash = '';
+        history.replaceState(null, '', window.location.pathname + window.location.search);
         const data = secrecyUserApp.safeParse(res);
         return data.success ? data.data : null;
     }
@@ -18,6 +30,7 @@ export function parseInfos() {
     }
 }
 export function getSecrecyClient(opts = {}) {
+    assertBrowser('getSecrecyClient');
     const storage = getStorage(opts.session);
     const infos = parseInfos();
     if (infos !== null) {
@@ -49,6 +62,7 @@ export function getSecrecyClient(opts = {}) {
     return null;
 }
 export async function login({ appId, context, path, redirect, scopes, backPath, session, secrecyUrls, forceLogin, }) {
+    assertBrowser('login');
     return await new Promise(async (resolve, reject) => {
         const appUrl = window.location.origin;
         const client = getSecrecyClient({ session, secrecyUrls });
@@ -129,3 +143,21 @@ export async function login({ appId, context, path, redirect, scopes, backPath,
         }
     });
 }
+/**
+ * Single async entry point: runs `setup()`, reuses an existing session if
+ * one is found, and falls back to `login()` otherwise. Equivalent to
+ * `await setup()` + `getSecrecyClient()` + `login()`, without having to
+ * juggle the sync/async mismatch between them.
+ */
+export async function initSecrecy(opts) {
+    assertBrowser('initSecrecy');
+    await setup();
+    const existing = getSecrecyClient({
+        session: opts.session,
+        secrecyUrls: opts.secrecyUrls,
+    });
+    if (existing !== null) {
+        return existing;
+    }
+    return await login(opts);
+}

package/dist/lib/client/index.js

@@ -2,8 +2,7 @@ import { BaseClient } from '../base-client.js';
 import { SecrecyCloudClient } from './SecrecyCloudClient.js';
 import { SecrecyMailClient } from './SecrecyMailClient.js';
 import { SecrecyAppClient } from './SecrecyAppClient.js';
-import { nodesCache, dataCache, publicKeysCache } from '../cache.js';
-import { SecrecyDbClient } from './SecrecyDbClient.js';
+import { clearAllCaches } from '../cache.js';
 import { SecrecyWalletClient } from './SecrecyWalletClient.js';
 import { SecrecyPayClient } from './SecrecyPayClient.js';
 import { SecrecyUserClient } from './SecrecyUserClient.js';
@@ -20,9 +19,10 @@ export class SecrecyClient extends BaseClient {
     cloud;
     mail;
     app;
-    db;
     organization;
+    /** @experimental Susceptible de changer sans version majeure. */
     wallet;
+    /** @experimental Susceptible de changer sans version majeure. */
     pay;
     user;
     pseudonym;
@@ -33,8 +33,9 @@ export class SecrecyClient extends BaseClient {
             session: opts.uaSession,
             secrecyUrls: opts.secrecyUrls,
             apiClient: opts.apiClient,
+            timeoutMs: opts.timeoutMs,
+            reloadOnAccessDenied: opts.reloadOnAccessDenied,
             onAccessDenied: async () => {
-                console.log('[CLIENT] - Access denied');
                 try {
                     await this.logout();
                 }
@@ -53,7 +54,6 @@ export class SecrecyClient extends BaseClient {
         this.cloud = new SecrecyCloudClient(this);
         this.mail = new SecrecyMailClient(this);
         this.app = new SecrecyAppClient(opts.uaJwt, this);
-        this.db = new SecrecyDbClient(this);
         this.organization = new SecrecyOrganizationClient(this);
         this.wallet = new SecrecyWalletClient(this);
         this.pay = new SecrecyPayClient(this);
@@ -104,9 +104,7 @@ export class SecrecyClient extends BaseClient {
         });
     }
     async logout(sessionId) {
-        nodesCache.clear();
-        dataCache.clear();
-        publicKeysCache.clear();
+        clearAllCaches();
         await super.logout(sessionId);
     }
 }

package/dist/lib/client.js

@@ -24,26 +24,22 @@ export const createTRPCClient = (opts) => innerCreateTRPCClient({
                 : 'https://api.secrecy.tech/trpc',
             maxURLLength: 2083,
             fetch: async (input, init) => {
-                const controller = new AbortController();
-                const id = setTimeout(() => {
-                    controller.abort();
-                }, 20000);
+                const timeout = AbortSignal.timeout(opts.timeoutMs ?? 20_000);
+                const signal = init?.signal
+                    ? AbortSignal.any([init.signal, timeout])
+                    : timeout;
                 const headers = new Headers(init?.headers);
                 headers.set('secrecy-lib-version', SECRECY_LIB_VERSION);
                 if (typeof opts.session === 'string') {
                     headers.set('secrecy-session', opts.session);
                 }
-                const call = fetch(input, {
+                return await fetch(input, {
                     ...init,
                     headers,
-                    signal: controller.signal,
+                    signal,
                     mode: 'cors',
                     credentials: opts.session ? 'include' : 'omit',
                 });
-                void call.finally(() => {
-                    clearTimeout(id);
-                });
-                return await call;
             },
         }),
     ],

package/dist/lib/crypto/index.js

@@ -1,5 +1,12 @@
 import { concatenate } from '../utils/array.js';
 import { sodium } from '../sodium.js';
+function dataTooShortError() {
+    return {
+        name: 'ClientError',
+        code: 'DATA_TOO_SHORT',
+        message: 'Encrypted payload is shorter than nonce + MAC',
+    };
+}
 export function encryptCryptoBox(data, publicKeyBob, privateKeyAlice) {
     const nonce = sodium.randombytes_buf(sodium.crypto_box_NONCEBYTES);
     const crypt = sodium.crypto_box_easy(data, nonce, sodium.from_hex(publicKeyBob), sodium.from_hex(privateKeyAlice));
@@ -10,7 +17,7 @@ export function generateCryptoBoxKeyPair() {
 }
 export function decryptCryptoBox(data, publicKeyAlice, privateKeyBob) {
     if (data.length < sodium.crypto_box_NONCEBYTES + sodium.crypto_box_MACBYTES) {
-        throw 'data too short';
+        throw dataTooShortError();
     }
     const nonce = data.slice(0, sodium.crypto_box_NONCEBYTES);
     const cipher = data.slice(sodium.crypto_box_NONCEBYTES);
@@ -27,7 +34,7 @@ export function encryptSecretBox(data, key) {
 export function decryptSecretBox(data, key) {
     if (data.length <
         sodium.crypto_secretbox_NONCEBYTES + sodium.crypto_secretbox_MACBYTES) {
-        throw 'data too short';
+        throw dataTooShortError();
     }
     const nonce = data.slice(0, sodium.crypto_secretbox_NONCEBYTES);
     const cipher = data.slice(sodium.crypto_secretbox_NONCEBYTES);

package/dist/lib/error/client.js

@@ -1,5 +1,11 @@
 import { z } from 'zod';
-export const clientErrorCodeKey = z.enum(['NOT_FOUND']);
+export const clientErrorCodeKey = z.enum([
+    'NOT_FOUND',
+    'DATA_TOO_SHORT',
+    'POPUP_BLOCKED',
+    'POPUP_CLOSED',
+    'SERVER_ENVIRONMENT',
+]);
 export const clientError = z.object({
     name: z.literal('ClientError'),
     code: clientErrorCodeKey,

package/dist/lib/react/index.js

@@ -0,0 +1,69 @@
+import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useState, } from 'react';
+import { initSecrecy, login as secrecyLogin } from '../client/helpers.js';
+const SecrecyContext = createContext(null);
+export function SecrecyProvider(props) {
+    const { appId, session, redirect, secrecyUrls, children } = props;
+    const [client, setClient] = useState(null);
+    const [status, setStatus] = useState('idle');
+    const [error, setError] = useState(null);
+    const secrecyUrlsKey = JSON.stringify(secrecyUrls ?? null);
+    useEffect(() => {
+        let cancelled = false;
+        setStatus('loading');
+        initSecrecy({ appId, session, redirect, secrecyUrls })
+            .then((result) => {
+            if (cancelled)
+                return;
+            setClient(result);
+            setStatus(result !== null ? 'authenticated' : 'idle');
+        })
+            .catch((err) => {
+            if (cancelled)
+                return;
+            setError(err);
+            setStatus('error');
+        });
+        return () => {
+            cancelled = true;
+        };
+        // secrecyUrls is tracked through secrecyUrlsKey, a stable primitive.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [appId, session, redirect, secrecyUrlsKey]);
+    const login = useCallback(async () => {
+        setStatus('loading');
+        setError(null);
+        try {
+            const result = await secrecyLogin({
+                appId,
+                session,
+                secrecyUrls,
+                forceLogin: true,
+            });
+            setClient(result);
+            setStatus('authenticated');
+        }
+        catch (err) {
+            setError(err);
+            setStatus('error');
+        }
+        // secrecyUrls is tracked through secrecyUrlsKey, a stable primitive.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [appId, session, secrecyUrlsKey]);
+    const logout = useCallback(async () => {
+        if (client === null) {
+            return;
+        }
+        await client.logout();
+        setClient(null);
+        setStatus('idle');
+    }, [client]);
+    const value = useMemo(() => ({ client, status, error, login, logout }), [client, status, error, login, logout]);
+    return createElement(SecrecyContext.Provider, { value }, children);
+}
+export function useSecrecy() {
+    const ctx = useContext(SecrecyContext);
+    if (ctx === null) {
+        throw new Error('useSecrecy() must be used within a <SecrecyProvider>');
+    }
+    return ctx;
+}

package/dist/lib/utils/popup-tools.js

@@ -10,7 +10,6 @@ const defaultOptions = {
     scrollbars: 'no',
     centered: true,
 };
-let popupCount = 1;
 /**
  * Return options converted to a string
  *
@@ -23,12 +22,11 @@ function optionsToString(options) {
         .join(',');
 }
 /**
- * Get a unique name on each call
+ * Get an unpredictable, unique name on each call
  * @return {String}
  */
 function defaultPopupName() {
-    popupCount += 1;
-    return `Popup ${popupCount}`;
+    return `secrecy-${crypto.randomUUID()}`;
 }
 /**
  * Convert "centered: true" key into concrete left and top arguments
@@ -101,6 +99,7 @@ function popupExecute(execute, url, name, options, callback) {
         };
     const optionsString = optionsToString(popupOptions);
     const win = execute(url, popupName, optionsString);
+    const expectedOrigin = new URL(url, window.location.href).origin;
     let isMessageSent = false;
     let interval;
     function popupCallbackOnce(err, data) {
@@ -110,7 +109,11 @@ function popupExecute(execute, url, name, options, callback) {
         }
     }
     function onMessage(message) {
-        const data = message !== undefined ? message.data : undefined;
+        if (message === undefined || message.origin !== expectedOrigin) {
+            console.error('Invalid message origin', message?.origin, expectedOrigin);
+            return;
+        }
+        const data = message.data;
         if (data !== undefined && data.id === popupName) {
             popupCallbackOnce(undefined, data.data);
             window.removeEventListener('message', onMessage);
@@ -123,13 +126,21 @@ function popupExecute(execute, url, name, options, callback) {
             if (win === null || win.closed) {
                 setTimeout(function delayWindowClosing() {
                     clearInterval(interval);
-                    popupCallbackOnce(new Error('Popup closed'));
+                    popupCallbackOnce({
+                        name: 'ClientError',
+                        code: 'POPUP_CLOSED',
+                        message: 'The popup was closed before completing',
+                    });
                 }, 500);
             }
         }, 100);
     }
     else {
-        popupCallbackOnce(new Error('Popup blocked'));
+        popupCallbackOnce({
+            name: 'ClientError',
+            code: 'POPUP_BLOCKED',
+            message: 'The popup was blocked by the browser',
+        });
     }
     return win;
 }
@@ -170,11 +181,8 @@ export function popupWithPost(url, postData, name, options, callback) {
 }
 /**
  * Return html that when executed, will trigger the popup to callback with a response
- *
- * @param  {Object}
- * @return {String}
  */
-export function popupResponse(id, data) {
+export function popupResponse(id, data, targetOrigin) {
     const jsonData = JSON.stringify({ id, data });
-    return `<script>window.opener.postMessage(${jsonData}, "*");setTimeout(function() { window.close(); }, 50);</script>`;
+    return `<script>window.opener.postMessage(${jsonData}, ${JSON.stringify(targetOrigin)});setTimeout(function() { window.close(); }, 50);</script>`;
 }

package/dist/types/base-client.d.ts

@@ -12,6 +12,8 @@ export type BaseClientOptions = {
     apiClient?: ApiClient;
     onAccessDenied?: () => void | Promise<void>;
     secrecyUrls?: Partial<SecrecyUrls>;
+    timeoutMs?: number;
+    reloadOnAccessDenied?: boolean;
 };
 export declare class BaseClient {
     #private;

package/dist/types/cache.d.ts

@@ -1,17 +1,18 @@
 import type { InternalNode, InternalData, InternalNodeFull, LocalData, InternalMinimalNodeForEncryption } from './client/types/index.js';
 import { LRUCache } from 'lru-cache';
 type NodeForEncryptionCached = InternalNode | InternalNodeFull | InternalMinimalNodeForEncryption;
-export declare const dataCache: Map<string, InternalData>;
-export declare const nodesCache: Map<string, InternalNode | InternalNodeFull>;
-export declare const nodesEncryptionCache: Map<string, InternalMinimalNodeForEncryption>;
+export declare const dataCache: LRUCache<string, InternalData, unknown>;
+export declare const nodesCache: LRUCache<string, InternalNode | InternalNodeFull, unknown>;
+export declare const nodesEncryptionCache: LRUCache<string, InternalMinimalNodeForEncryption, unknown>;
 export declare const getNodeForEncryptionFromCache: (id: string) => NodeForEncryptionCached | undefined;
-export declare const usersCache: Map<string, {
+export declare const usersCache: LRUCache<string, {
     firstname: string;
     lastname: string;
     id: string;
     avatar: string | null;
     isSearchable: boolean;
-}>;
-export declare const publicKeysCache: Map<string, string>;
+}, unknown>;
+export declare const publicKeysCache: LRUCache<string, string, unknown>;
 export declare const dataContentCache: LRUCache<string, LocalData, unknown>;
+export declare function clearAllCaches(): void;
 export {};

package/dist/types/client/SecrecyMailClient.d.ts

@@ -13,9 +13,23 @@ export declare class SecrecyMailClient {
     deletedMails({ mailType, }: {
         mailType: ApiMail['type'];
     }): Promise<Mail[]>;
+    create(data: NewMail & {
+        customMessage?: string | null | undefined;
+    }): Promise<SentMail>;
+    /**
+     * @deprecated Pass a single object instead:
+     * `create({ ...data, customMessage })`.
+     */
     create(data: NewMail, customMessage?: string | null | undefined): Promise<SentMail>;
     waitingReceivedMails(): Promise<WaitingReceivedMail[]>;
-    updateDraft(draftId: string, { body, subject, senderFiles, recipients, replyToId }: Partial<NewMail>): Promise<DraftMail>;
+    updateDraft(input: {
+        draftId: string;
+    } & Partial<NewMail>): Promise<DraftMail>;
+    /**
+     * @deprecated Pass a single object instead:
+     * `updateDraft({ draftId, ...args })`.
+     */
+    updateDraft(draftId: string, args: Partial<NewMail>): Promise<DraftMail>;
     deleteDraft(draftId: string): Promise<boolean>;
     deleteTrash({ ids }: {
         ids: string[];
@@ -24,6 +38,14 @@ export declare class SecrecyMailClient {
     delete({ mailId }: {
         mailId: string;
     }): Promise<boolean>;
+    sendDraft(input: {
+        draftId: string;
+        customMessage?: string | null | undefined;
+    }): Promise<boolean>;
+    /**
+     * @deprecated Pass a single object instead:
+     * `sendDraft({ draftId, customMessage })`.
+     */
     sendDraft(draftId: string, customMessage?: string | null | undefined): Promise<boolean>;
     sendWaitingEmails(): Promise<void>;
     createDraft({ body, subject, senderFiles, recipients, replyToId, }: NewMail): Promise<DraftMail>;

package/dist/types/client/helpers.d.ts

@@ -1,6 +1,7 @@
 import { SecrecyClient } from './index.js';
 import { type SecrecyUserApp } from './types/index.js';
 import type { SecrecyUrls } from '../base-client.js';
+export declare function assertBrowser(fn: string): void;
 export declare function parseInfos(): SecrecyUserApp | null;
 export interface HashInfos {
     appId?: string;
@@ -29,4 +30,16 @@ type LoginResponse<Params extends UseSecrecyParams> = Params extends {
     redirect: true;
 } ? SecrecyClient | null : SecrecyClient;
 export declare function login<Params extends UseSecrecyParams>({ appId, context, path, redirect, scopes, backPath, session, secrecyUrls, forceLogin, }: Params): Promise<LoginResponse<Params>>;
+/**
+ * Single async entry point: runs `setup()`, reuses an existing session if
+ * one is found, and falls back to `login()` otherwise. Equivalent to
+ * `await setup()` + `getSecrecyClient()` + `login()`, without having to
+ * juggle the sync/async mismatch between them.
+ */
+export declare function initSecrecy(opts: {
+    appId: string;
+    session?: boolean | undefined;
+    redirect?: boolean | undefined;
+    secrecyUrls?: Partial<SecrecyUrls>;
+}): Promise<SecrecyClient | null>;
 export {};

package/dist/types/client/index.d.ts

@@ -3,7 +3,6 @@ import type { SecretStreamProgress } from '../crypto/data.js';
 import { SecrecyCloudClient } from './SecrecyCloudClient.js';
 import { SecrecyMailClient } from './SecrecyMailClient.js';
 import { SecrecyAppClient } from './SecrecyAppClient.js';
-import { SecrecyDbClient } from './SecrecyDbClient.js';
 import { SecrecyWalletClient } from './SecrecyWalletClient.js';
 import { SecrecyPayClient } from './SecrecyPayClient.js';
 import { type ApiClient, type RouterInputs } from '../client.js';
@@ -22,15 +21,18 @@ export interface SecrecyClientOptions {
     uaJwt: string;
     apiClient?: ApiClient;
     secrecyUrls?: Partial<SecrecyUrls>;
+    timeoutMs?: number;
+    reloadOnAccessDenied?: boolean;
 }
 export declare class SecrecyClient extends BaseClient {
     #private;
     cloud: SecrecyCloudClient;
     mail: SecrecyMailClient;
     app: SecrecyAppClient;
-    db: SecrecyDbClient;
     organization: SecrecyOrganizationClient;
+    /** @experimental Susceptible de changer sans version majeure. */
     wallet: SecrecyWalletClient;
+    /** @experimental Susceptible de changer sans version majeure. */
     pay: SecrecyPayClient;
     user: SecrecyUserClient;
     pseudonym: SecrecyPseudonymClient;

package/dist/types/client.d.ts

@@ -8,6 +8,7 @@ export interface CreateTrpcClientOptions {
     session?: string | null | undefined;
     apiUrl?: string | null | undefined;
     onAccessDenied?: () => void | Promise<void> | null | undefined;
+    timeoutMs?: number | undefined;
 }
 export declare const createTRPCClient: (opts: CreateTrpcClientOptions) => import("@trpc/client").TRPCClient<import("@trpc/server").TRPCBuiltRouter<{
     ctx: any;

package/dist/types/error/client.d.ts

@@ -1,12 +1,20 @@
 import { z } from 'zod';
 export declare const clientErrorCodeKey: z.ZodEnum<{
     NOT_FOUND: "NOT_FOUND";
+    DATA_TOO_SHORT: "DATA_TOO_SHORT";
+    POPUP_BLOCKED: "POPUP_BLOCKED";
+    POPUP_CLOSED: "POPUP_CLOSED";
+    SERVER_ENVIRONMENT: "SERVER_ENVIRONMENT";
 }>;
 export type CLIENT_ERROR_CODE_KEY = z.infer<typeof clientErrorCodeKey>;
 export declare const clientError: z.ZodObject<{
     name: z.ZodLiteral<"ClientError">;
     code: z.ZodEnum<{
         NOT_FOUND: "NOT_FOUND";
+        DATA_TOO_SHORT: "DATA_TOO_SHORT";
+        POPUP_BLOCKED: "POPUP_BLOCKED";
+        POPUP_CLOSED: "POPUP_CLOSED";
+        SERVER_ENVIRONMENT: "SERVER_ENVIRONMENT";
     }>;
     message: z.ZodString;
 }, z.core.$strip>;

package/dist/types/error/index.d.ts

@@ -24,6 +24,10 @@ export declare const secrecyError: z.ZodDiscriminatedUnion<[z.ZodObject<{
     name: z.ZodLiteral<"ClientError">;
     code: z.ZodEnum<{
         NOT_FOUND: "NOT_FOUND";
+        DATA_TOO_SHORT: "DATA_TOO_SHORT";
+        POPUP_BLOCKED: "POPUP_BLOCKED";
+        POPUP_CLOSED: "POPUP_CLOSED";
+        SERVER_ENVIRONMENT: "SERVER_ENVIRONMENT";
     }>;
     message: z.ZodString;
 }, z.core.$strip>], "name">;

package/dist/types/react/index.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from 'react';
+import type { SecrecyClient } from '../client/index.js';
+import type { SecrecyUrls } from '../base-client.js';
+export type SecrecyStatus = 'idle' | 'loading' | 'authenticated' | 'error';
+export interface SecrecyContextValue {
+    client: SecrecyClient | null;
+    status: SecrecyStatus;
+    error: unknown;
+    login: () => Promise<void>;
+    logout: () => Promise<void>;
+}
+export interface SecrecyProviderProps {
+    appId: string;
+    session?: boolean | undefined;
+    redirect?: boolean | undefined;
+    secrecyUrls?: Partial<SecrecyUrls> | undefined;
+    children?: ReactNode;
+}
+export declare function SecrecyProvider(props: SecrecyProviderProps): ReactNode;
+export declare function useSecrecy(): SecrecyContextValue;

package/dist/types/utils/popup-tools.d.ts

@@ -1,6 +1,7 @@
 /**
  * TS Rewrite of https://github.com/enhancv/popup-tools
  */
+import { type ClientError } from '../error/client.js';
 type YesNo = 'yes' | 'no';
 interface Options {
     width?: number;
@@ -13,7 +14,7 @@ interface Options {
     left?: number;
     top?: number;
 }
-type Callback = (err?: Error, data?: unknown) => void;
+type Callback = (err?: ClientError, data?: unknown) => void;
 /**
  * Open a popup using the first argument.
  * Wait for it to close and call the callback.
@@ -44,9 +45,6 @@ export declare function popup(url: string, name: string, options: Partial<Option
 export declare function popupWithPost(url: string, postData: Record<string, string>, name: string, options: Partial<Options>, callback: Callback): Window | null;
 /**
  * Return html that when executed, will trigger the popup to callback with a response
- *
- * @param  {Object}
- * @return {String}
  */
-export declare function popupResponse<T>(id: string, data: T): string;
+export declare function popupResponse<T>(id: string, data: T, targetOrigin: string): string;
 export {};

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@secrecy/lib",
   "author": "Anonymize <anonymize@gmail.com>",
-  "description": "Anonymize Secrecy Library",
-  "version": "1.86.0",
+  "description": "Client-side end-to-end encryption SDK for Secrecy",
+  "version": "1.86.1-feat-improve-sdk.2",
+  "engines": {
+    "node": ">=22.21.1"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/anonymize-org/lib.git"
@@ -13,11 +16,12 @@
   },
   "homepage": "https://github.com/anonymize-org/lib#readme",
   "keywords": [
-    "anonymize",
-    "lib",
     "secrecy",
-    "wallet",
-    "stripe"
+    "e2ee",
+    "encryption",
+    "libsodium",
+    "zero-knowledge",
+    "browser"
   ],
   "type": "module",
   "exports": {
@@ -51,9 +55,12 @@
   "devDependencies": {
     "@commitlint/cli": "^20.3.0",
     "@commitlint/config-conventional": "^20.3.0",
+    "@happy-dom/global-registrator": "^20.11.2",
     "@prisma/client": "6.17.1",
+    "@trpc/server": "^11.6.0",
     "@types/bun": "^1.3.5",
     "@types/jsonwebtoken": "^9.0.10",
+    "@types/react": "^19.2.18",
     "@types/spark-md5": "^3.0.5",
     "@types/streamsaver": "^2.0.5",
     "@typescript-eslint/eslint-plugin": "^8.52.0",
@@ -67,6 +74,7 @@
     "husky": "^9.1.7",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.7.4",
+    "react": "^19.2.8",
     "rimraf": "^6.1.2",
     "semantic-release": "^25.0.2",
     "typedoc": "^0.28.15",
@@ -78,7 +86,6 @@
     "@js-temporal/polyfill": "^0.5.1",
     "@secrecy/trpc-api-types": "1.41.0-dev.1",
     "@trpc/client": "11.6.0",
-    "@trpc/server": "^11.6.0",
     "@types/libsodium-wrappers-sumo": "^0.7.8",
     "axios": "^1.13.2",
     "bson": "^7.0.0",
@@ -92,5 +99,13 @@
     "streamsaver": "^2.0.6",
     "superjson": "2.2.6",
     "zod": "4.3.5"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
   }
 }

package/dist/lib/client/SecrecyDbClient.js

@@ -1,3 +0,0 @@
-export class SecrecyDbClient {
-    constructor(_client) { }
-}

package/dist/types/client/SecrecyDbClient.d.ts

@@ -1,4 +0,0 @@
-import type { SecrecyClient } from '../index.js';
-export declare class SecrecyDbClient {
-    constructor(_client: SecrecyClient);
-}