@me2em/react 0.1.0-alpha.1 → 1.0.0-rc.1

package/src/react/index.ts

@@ -1,7 +1,10 @@
 export { Me2emProvider } from './Me2emProvider.js';
 export { useMe2emContext } from './context.js';
+export type { Me2emContextValue } from './context.js';
 export { useCreateIdentity } from './useCreateIdentity.js';
+export type { UseCreateIdentityResult } from './useCreateIdentity.js';
 export { useImportSeed } from './useImportSeed.js';
+export type { UseImportSeedResult } from './useImportSeed.js';
 export { useHandle } from './useHandle.js';
 export { useSubHandle } from './useSubHandle.js';
 export { SeedPhraseDisplay } from './SeedPhraseDisplay.js';

package/src/react/useCreateIdentity.ts

@@ -6,7 +6,7 @@ import {
 } from 'react';
 import {
   generateSeedPhrase,
-  get32ByteSeedFromMnemonic,
+  get64ByteSeedFromMnemonic,
   type SeedStrength,
   type Identity,
 } from '@me2em/core';
@@ -37,7 +37,7 @@ export function useCreateIdentity(): UseCreateIdentityResult {
   const generate = useCallback(
     (opts?: { strength?: SeedStrength }) => {
       const words = generateSeedPhrase(opts?.strength ?? 128);
-      get32ByteSeedFromMnemonic(words).then((derivedSeed) => {
+      get64ByteSeedFromMnemonic(words).then((derivedSeed) => {
         dispatch({ type: 'GENERATE', words, seed: derivedSeed });
       }).catch(() => {
         dispatch({ type: 'FAIL', message: 'Failed to generate seed' });

package/src/react/useHandle.ts

@@ -10,6 +10,7 @@ export function useHandle(name: string): Handle | null {
   useEffect(() => {
     let cancelled = false;
     if (!identity) {
+      // eslint-disable-next-line react-hooks/set-state-in-effect -- clearing the stale async result when identity is gone; set-during-render refactor is a tracked post-rc.2 follow-up
       setHandle(null);
       return;
     }

package/src/react/useIdentityContext.ts

@@ -1,5 +1,6 @@
 // packages/react/src/react/useIdentityContext.ts
 import { useState, useCallback, useEffect, useRef } from 'react';
+import type { Identity } from '@me2em/core';
 import type { IdentityContextStorage, IdentityContextData } from '../headless/identity-context-types.js';
 import { useMe2emContext } from './context.js';
 
@@ -9,6 +10,10 @@ function publicKeyToId(publicKey: Uint8Array): string {
     .join('');
 }
 
+function identityToId(identity: Identity | null): string | null {
+  return identity ? publicKeyToId(identity.getPublicKey()) : null;
+}
+
 export interface UseIdentityContextResult {
   context: IdentityContextData | null;
   isLoaded: boolean;
@@ -28,11 +33,23 @@ export function useIdentityContext(
   const [error, setError] = useState<string | null>(null);
 
   const prevIdentityIdRef = useRef<string | null>(null);
+  // Generation ticket for async state transitions. Load (identity
+  // change / `refresh()`), `save()` and `clear()` each take a ticket;
+  // a resolution may only commit state while its ticket is the newest
+  // one. Without this, an in-flight load started before a save could
+  // resolve after it and clobber the just-saved state with pre-save
+  // data (out-of-order async update — observed as a rare CI flake in
+  // the rerender spec; pinned there by a gated-storage test).
+  const opRef = useRef(0);
+  const identityRef = useRef<Identity | null>(null);
+  // eslint-disable-next-line react-hooks/refs -- render-time mirror of the latest identity: save()/clear() are stable callbacks (storage-only deps) and must verify at commit time, after their await, that the identity they started for is still the active one
+  identityRef.current = identity;
 
   useEffect(() => {
     let cancelled = false;
 
     if (!identity) {
+      // eslint-disable-next-line react-hooks/set-state-in-effect -- clearing the stale async state when identity is gone (generation-ticket effect from the load-race fix); set-during-render refactor is a tracked post-rc.2 follow-up
       setContext(null);
       setIsLoaded(true);
       setError(null);
@@ -49,9 +66,10 @@ export function useIdentityContext(
     prevIdentityIdRef.current = identityId;
 
     // Open storage for this identity and load cached context (atomic)
+    const op = ++opRef.current;
     storage.openAndLoad(identityId)
       .then((data) => {
-        if (cancelled) return;
+        if (cancelled || op !== opRef.current) return;
         setContext(data);
         setIsLoaded(true);
         setError(null);
@@ -68,19 +86,37 @@ export function useIdentityContext(
   }, [identity, storage]);
 
   const save = useCallback(async (data: IdentityContextData): Promise<void> => {
+    const idAtStart = identityToId(identityRef.current);
+    opRef.current += 1; // invalidate any in-flight load/refresh
     await storage.save(data);
+    // If the identity switched while the write was in flight, state
+    // ownership has moved to the new identity's load effect — committing
+    // here would surface identity A's context under identity B. The
+    // generation ticket above only orders this op against in-flight
+    // loads; it does not know about identity switches.
+    if (identityToId(identityRef.current) !== idAtStart) return;
     setContext(data);
+    setError(null);
   }, [storage]);
 
   const clear = useCallback(async (): Promise<void> => {
+    const idAtStart = identityToId(identityRef.current);
+    opRef.current += 1; // invalidate any in-flight load/refresh
     await storage.clear();
+    // Same ownership rule as save(): a clear() resolving after an
+    // identity switch must not blank the new identity's freshly
+    // loaded context.
+    if (identityToId(identityRef.current) !== idAtStart) return;
     setContext(null);
+    setError(null);
   }, [storage]);
 
   const refresh = useCallback(async (): Promise<void> => {
     if (!identity) return;
     const identityId = publicKeyToId(identity.getPublicKey());
+    const op = ++opRef.current;
     const data = await storage.openAndLoad(identityId);
+    if (op !== opRef.current) return;
     setContext(data);
   }, [identity, storage]);
 

package/src/react/useImportSeed.ts

@@ -2,7 +2,7 @@
 import { useReducer, useCallback, type Reducer } from 'react';
 import {
   validateSeedPhrase,
-  get32ByteSeedFromMnemonic,
+  get64ByteSeedFromMnemonic,
   type Identity,
 } from '@me2em/core';
 import {
@@ -34,7 +34,7 @@ export function useImportSeed(): UseImportSeedResult {
         return;
       }
       try {
-        const seed = await get32ByteSeedFromMnemonic(words, passphrase ?? '');
+        const seed = await get64ByteSeedFromMnemonic(words, passphrase ?? '');
         dispatch({ type: 'IMPORT', seed });
         await activateIdentity(seed);
       } catch (err) {

package/src/react/useSession.ts

@@ -1,8 +1,7 @@
 // packages/react/src/react/useSession.ts
 import { useState, useEffect, useCallback, useRef } from 'react';
 import type { Handle } from '@me2em/core';
-import { Session, type SessionOptions, type SessionPayload } from '@me2em/core';
-import { useMe2emContext } from './context.js';
+import { Session } from '@me2em/core';
 
 /**
  * Options for useSession, memoized via deep comparison of
@@ -74,7 +73,6 @@ export function useSession(
   options: UseSessionOptions,
   autoRenew: boolean = true
 ): UseSessionResult {
-  const { identity } = useMe2emContext();
   const [session, setSession] = useState<Session | null>(null);
   const [isLoaded, setIsLoaded] = useState(false);
   const [error, setError] = useState<string | null>(null);
@@ -82,8 +80,11 @@ export function useSession(
   const optionsRef = useRef(options);
   const mountedRef = useRef(true);
 
-  // Update options ref without triggering re-renders
-  optionsRef.current = options;
+  // Mirror the latest options into the ref after every commit —
+  // ref writes belong in effects, not during render (react-hooks/refs).
+  useEffect(() => {
+    optionsRef.current = options;
+  });
 
   const clearTimer = useCallback(() => {
     if (timerRef.current) {
@@ -128,6 +129,7 @@ export function useSession(
         const halfLife = Math.floor((s.expiresAt * 1000 - Date.now()) / 2);
         if (halfLife > 0) {
           timerRef.current = setTimeout(() => {
+            // eslint-disable-next-line react-hooks/immutability -- self-rescheduling renewal timer: the timer is cleared and re-created whenever renew itself changes (deps + clearTimer), so the captured binding is always the current one
             renew();
           }, Math.max(halfLife, 1000));
         }

package/src/react/useSubHandle.ts

@@ -12,6 +12,7 @@ export function useSubHandle(
   useEffect(() => {
     let cancelled = false;
     if (!identity) {
+      // eslint-disable-next-line react-hooks/set-state-in-effect -- clearing the stale async result when identity is gone; set-during-render refactor is a tracked post-rc.2 follow-up
       setSubHandle(null);
       return;
     }

package/src/headless/context-key-store.ts

@@ -1,124 +0,0 @@
-// packages/react/src/headless/context-key-store.ts
-import type { IdentityContextData } from './identity-context-storage.js';
-
-const KEYS_PREFIX = '__keys:';
-
-export interface ContextKeyStore {
-  /** Save a persisted CryptoKey for later use. */
-  setCacheKey(key: CryptoKey): Promise<void>;
-  /** Retrieve the persisted CryptoKey, or null if not found. */
-  getCacheKey(): Promise<CryptoKey | null>;
-  /** Delete the persisted CryptoKey (called on logout). */
-  deleteCacheKey(): Promise<void>;
-  /** Persist the CryptoKey to IndexedDB for warm return after browser restart. */
-  persistCacheKey(): Promise<void>;
-  /** Load a previously persisted CryptoKey from IndexedDB. */
-  loadPersistedKey(): Promise<CryptoKey | null>;
-}
-
-/**
- * IndexedDB-backed key store. CryptoKey objects are structured-cloned
- * into an object store 'cryptoKeys' so they survive browser restarts.
- */
-export class InMemoryKeyStore implements ContextKeyStore {
-  private db: IDBDatabase | null = null;
-
-  private getDbName(identityId: string): string {
-    return `${KEYS_PREFIX}${identityId}`;
-  }
-
-  private async openOrCreate(): Promise<IDBDatabase> {
-    if (this.db) return this.db;
-
-    const name = this.getDbName('default');
-    return new Promise<IDBDatabase>((resolve, reject) => {
-      const request = indexedDB.open(name, 1);
-
-      request.onupgradeneeded = () => {
-        const db = request.result;
-        if (!db.objectStoreNames.contains('keys')) {
-          db.createObjectStore('keys', { keyPath: 'key' });
-        }
-        if (!db.objectStoreNames.contains('cryptoKeys')) {
-          db.createObjectStore('cryptoKeys', { keyPath: 'key' });
-        }
-      };
-
-      request.onsuccess = () => {
-        this.db = request.result;
-        resolve(request.result);
-      };
-
-      request.onerror = () => reject(new Error('Keys DB open failed'));
-    });
-  }
-
-  async setCacheKey(key: CryptoKey): Promise<void> {
-    this.cacheKey = key;
-    const db = await this.openOrCreate();
-    return new Promise<void>((resolve, reject) => {
-      const tx = db.transaction('cryptoKeys', 'readwrite');
-      const store = tx.objectStore('cryptoKeys');
-      store.put({ key: 'cacheKey', cryptoKey: key });
-
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(new Error('setCacheKey failed: ' + tx.error?.message));
-    });
-  }
-
-  private cacheKey: CryptoKey | null = null;
-
-  async getCacheKey(): Promise<CryptoKey | null> {
-    if (this.cacheKey) return this.cacheKey;
-    return this.loadPersistedKey();
-  }
-
-  async deleteCacheKey(): Promise<void> {
-    this.cacheKey = null;
-    const db = await this.openOrCreate();
-    return new Promise<void>((resolve, reject) => {
-      const tx = db.transaction('cryptoKeys', 'readwrite');
-      const store = tx.objectStore('cryptoKeys');
-      store.delete('cacheKey');
-
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(new Error('deleteCacheKey failed: ' + tx.error?.message));
-    });
-  }
-
-  async persistCacheKey(): Promise<void> {
-    const key = this.cacheKey;
-    if (!key) {
-      throw new Error('No cache key to persist');
-    }
-    const db = await this.openOrCreate();
-    return new Promise<void>((resolve, reject) => {
-      const tx = db.transaction('cryptoKeys', 'readwrite');
-      const store = tx.objectStore('cryptoKeys');
-      store.put({ key: 'cacheKey', cryptoKey: key });
-
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(new Error('persistCacheKey failed: ' + tx.error?.message));
-    });
-  }
-
-  async loadPersistedKey(): Promise<CryptoKey | null> {
-    const db = await this.openOrCreate();
-    return new Promise<CryptoKey | null>((resolve, reject) => {
-      const tx = db.transaction('cryptoKeys', 'readonly');
-      const store = tx.objectStore('cryptoKeys');
-      const request = store.get('cacheKey');
-
-      request.onsuccess = () => {
-        const record = request.result;
-        if (!record || !record.cryptoKey) {
-          resolve(null);
-          return;
-        }
-        resolve(record.cryptoKey);
-      };
-
-      request.onerror = () => resolve(null);
-    });
-  }
-}