@me2em/react 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1225 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/react/Me2emProvider.tsx
+import {
+  useState,
+  useCallback,
+  useMemo
+} from "react";
+import { Identity } from "@me2em/core";
+
+// src/react/context.ts
+import { createContext, useContext } from "react";
+var Me2emContext = createContext(null);
+function useMe2emContext() {
+  const ctx = useContext(Me2emContext);
+  if (!ctx) {
+    throw new Error("Me2em hooks must be used inside <Me2emProvider>");
+  }
+  return ctx;
+}
+
+// src/react/Me2emProvider.tsx
+import { jsx } from "react/jsx-runtime";
+function Me2emProvider({ children }) {
+  const [identity, setIdentity] = useState(null);
+  const activateIdentity = useCallback(async (seed) => {
+    try {
+      const id = await Identity.fromSeed(seed);
+      setIdentity(id);
+      return true;
+    } catch {
+      return false;
+    }
+  }, []);
+  const clearIdentity = useCallback(() => {
+    setIdentity(null);
+  }, []);
+  const value = useMemo(
+    () => ({ identity, hasIdentity: identity !== null, activateIdentity, clearIdentity }),
+    [identity, activateIdentity, clearIdentity]
+  );
+  return /* @__PURE__ */ jsx(Me2emContext.Provider, { value, children });
+}
+
+// src/react/useCreateIdentity.ts
+import {
+  useReducer,
+  useCallback as useCallback2
+} from "react";
+import {
+  generateSeedPhrase,
+  get32ByteSeedFromMnemonic
+} from "@me2em/core";
+
+// src/headless/identity-flow.ts
+var initialIdentityFlowState = {
+  status: "idle",
+  seedWords: null,
+  identitySeed: null,
+  error: null
+};
+var UNEXPECTED_EVENTS = {
+  CONFIRM_WORDS: "CONFIRM_WORDS called from idle \u2014 no seed to confirm",
+  RESET: "RESET called from idle \u2014 nothing to reset"
+};
+function identityFlowReducer(state, event) {
+  const { type } = event;
+  switch (state.status) {
+    case "idle": {
+      if (type === "GENERATE") {
+        return {
+          status: "seed-generated",
+          seedWords: event.words,
+          identitySeed: event.seed,
+          error: null
+        };
+      }
+      if (type === "IMPORT") {
+        return {
+          status: "imported",
+          seedWords: null,
+          identitySeed: event.seed,
+          error: null
+        };
+      }
+      if (type === "FAIL") {
+        return {
+          status: "error",
+          seedWords: null,
+          identitySeed: null,
+          error: event.message
+        };
+      }
+      if (UNEXPECTED_EVENTS[type]) {
+        console.warn(UNEXPECTED_EVENTS[type]);
+        return state;
+      }
+      return state;
+    }
+    case "seed-generated": {
+      if (type === "CONFIRM_WORDS") {
+        return {
+          status: "verified",
+          seedWords: null,
+          identitySeed: state.identitySeed,
+          error: null
+        };
+      }
+      if (type === "FAIL") {
+        return {
+          status: "error",
+          seedWords: null,
+          identitySeed: null,
+          error: event.message
+        };
+      }
+      if (type === "RESET") {
+        return initialIdentityFlowState;
+      }
+      console.warn(`Unexpected event ${type} in seed-generated`);
+      return state;
+    }
+    case "verified":
+    case "imported": {
+      if (type === "RESET") {
+        return initialIdentityFlowState;
+      }
+      if (type === "FAIL") {
+        return {
+          status: "error",
+          seedWords: null,
+          identitySeed: null,
+          error: event.message
+        };
+      }
+      console.warn(`Unexpected event ${type} in ${state.status}`);
+      return state;
+    }
+    case "error": {
+      if (type === "RESET") {
+        return initialIdentityFlowState;
+      }
+      console.warn(`Unexpected event ${type} in error`);
+      return state;
+    }
+    default:
+      return state;
+  }
+}
+
+// src/react/useCreateIdentity.ts
+function useCreateIdentity() {
+  const { activateIdentity, clearIdentity, identity } = useMe2emContext();
+  const [state, dispatch] = useReducer(identityFlowReducer, initialIdentityFlowState);
+  const generate = useCallback2(
+    (opts) => {
+      const words = generateSeedPhrase(opts?.strength ?? 128);
+      get32ByteSeedFromMnemonic(words).then((derivedSeed) => {
+        dispatch({ type: "GENERATE", words, seed: derivedSeed });
+      }).catch(() => {
+        dispatch({ type: "FAIL", message: "Failed to generate seed" });
+      });
+    },
+    []
+  );
+  const confirmWords = useCallback2(async () => {
+    if (state.status !== "seed-generated" || !state.identitySeed) return;
+    dispatch({ type: "CONFIRM_WORDS" });
+    const ok = await activateIdentity(state.identitySeed);
+    if (!ok) {
+      dispatch({ type: "FAIL", message: "Identity activation failed" });
+    }
+  }, [state.status, state.identitySeed, activateIdentity]);
+  const reset = useCallback2(() => {
+    dispatch({ type: "RESET" });
+    clearIdentity();
+  }, [clearIdentity]);
+  const fail = useCallback2((message) => {
+    dispatch({ type: "FAIL", message });
+  }, []);
+  return {
+    status: state.status,
+    seedWords: state.seedWords,
+    identity,
+    error: state.error,
+    generate,
+    confirmWords,
+    reset,
+    fail
+  };
+}
+
+// src/react/useImportSeed.ts
+import { useReducer as useReducer2, useCallback as useCallback3 } from "react";
+import {
+  validateSeedPhrase,
+  get32ByteSeedFromMnemonic as get32ByteSeedFromMnemonic2
+} from "@me2em/core";
+function useImportSeed() {
+  const { activateIdentity, clearIdentity, identity } = useMe2emContext();
+  const [state, dispatch] = useReducer2(identityFlowReducer, initialIdentityFlowState);
+  const importWords = useCallback3(
+    async (words, passphrase) => {
+      const validation = validateSeedPhrase(words);
+      if (!validation.isValid) {
+        dispatch({ type: "FAIL", message: validation.error ?? "Invalid seed phrase" });
+        return;
+      }
+      try {
+        const seed = await get32ByteSeedFromMnemonic2(words, passphrase ?? "");
+        dispatch({ type: "IMPORT", seed });
+        await activateIdentity(seed);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Import failed";
+        dispatch({ type: "FAIL", message });
+      }
+    },
+    [activateIdentity]
+  );
+  const reset = useCallback3(() => {
+    dispatch({ type: "RESET" });
+    clearIdentity();
+  }, [clearIdentity]);
+  return {
+    status: state.status,
+    identity,
+    error: state.error,
+    importWords,
+    reset
+  };
+}
+
+// src/react/useHandle.ts
+import { useState as useState2, useEffect } from "react";
+function useHandle(name) {
+  const { identity } = useMe2emContext();
+  const [handle, setHandle] = useState2(null);
+  useEffect(() => {
+    let cancelled = false;
+    if (!identity) {
+      setHandle(null);
+      return;
+    }
+    identity.deriveHandle(name).then((h) => {
+      if (!cancelled) setHandle(h);
+    }).catch((err) => {
+      if (!cancelled) console.error("useHandle derivation failed", err);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [identity, name]);
+  return handle;
+}
+
+// src/react/useSubHandle.ts
+import { useState as useState3, useEffect as useEffect2 } from "react";
+function useSubHandle(handleName, subName) {
+  const { identity } = useMe2emContext();
+  const [subHandle, setSubHandle] = useState3(null);
+  useEffect2(() => {
+    let cancelled = false;
+    if (!identity) {
+      setSubHandle(null);
+      return;
+    }
+    identity.deriveSubHandle(handleName, subName).then((h) => {
+      if (!cancelled) setSubHandle(h);
+    }).catch((err) => {
+      if (!cancelled) console.error("useSubHandle derivation failed", err);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [identity, handleName, subName]);
+  return subHandle;
+}
+
+// src/react/SeedPhraseDisplay.tsx
+import { useReducer as useReducer3, useState as useState4 } from "react";
+
+// src/headless/display-flow.ts
+var initialDisplayState = {
+  status: "hidden",
+  copyCount: 0,
+  revealedAt: null
+};
+function displayFlowReducer(state, event) {
+  const { type } = event;
+  switch (state.status) {
+    case "hidden": {
+      if (type === "REVEAL") {
+        return {
+          status: "revealed",
+          copyCount: 0,
+          revealedAt: event.at
+        };
+      }
+      if (type === "COPY") {
+        console.warn("Cannot copy while hidden");
+        return state;
+      }
+      if (type === "RESET") {
+        return initialDisplayState;
+      }
+      if (type === "DISMISS") {
+        console.warn("Cannot dismiss while hidden");
+        return state;
+      }
+      console.warn(`Unexpected event ${type} in hidden`);
+      return state;
+    }
+    case "revealed": {
+      if (type === "COPY") {
+        if (state.copyCount === 0) {
+          return {
+            status: "copied",
+            copyCount: 1,
+            revealedAt: state.revealedAt
+          };
+        }
+        console.warn("Already copied \u2014 duplicate copy blocked");
+        return state;
+      }
+      if (type === "DISMISS") {
+        return {
+          status: "dismissed",
+          copyCount: state.copyCount,
+          revealedAt: state.revealedAt
+        };
+      }
+      if (type === "RESET") {
+        return initialDisplayState;
+      }
+      console.warn(`Unexpected event ${type} in revealed`);
+      return state;
+    }
+    case "copied": {
+      if (type === "COPY") {
+        console.warn("Already copied \u2014 duplicate copy blocked");
+        return state;
+      }
+      if (type === "DISMISS") {
+        return {
+          status: "dismissed",
+          copyCount: 1,
+          revealedAt: state.revealedAt
+        };
+      }
+      if (type === "RESET") {
+        return initialDisplayState;
+      }
+      console.warn(`Unexpected event ${type} in copied`);
+      return state;
+    }
+    case "dismissed": {
+      if (type === "RESET") {
+        return initialDisplayState;
+      }
+      console.warn(`Unexpected event ${type} in dismissed`);
+      return state;
+    }
+    default:
+      return state;
+  }
+}
+
+// src/react/SeedPhraseDisplay.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function SeedPhraseDisplay({
+  words,
+  onDismiss,
+  onCopyAllowed
+}) {
+  const [state, dispatch] = useReducer3(displayFlowReducer, initialDisplayState);
+  const [copyFailed, setCopyFailed] = useState4(false);
+  const { status, copyCount } = state;
+  const handleReveal = () => {
+    dispatch({ type: "REVEAL", at: Date.now() });
+  };
+  const handleCopy = async () => {
+    if (status === "revealed" && copyCount === 0) {
+      try {
+        await navigator.clipboard.writeText(words.join(" "));
+        dispatch({ type: "COPY", at: Date.now() });
+        setCopyFailed(false);
+        onCopyAllowed?.();
+      } catch {
+        setCopyFailed(true);
+      }
+    }
+  };
+  const handleDismiss = () => {
+    dispatch({ type: "DISMISS" });
+    onDismiss?.();
+  };
+  if (status === "hidden") {
+    return /* @__PURE__ */ jsx2("button", { "data-testid": "reveal", onClick: handleReveal, children: "Reveal" });
+  }
+  if (status === "dismissed") {
+    return /* @__PURE__ */ jsx2("div", { "data-testid": "dismissed", children: "Phrase dismissed" });
+  }
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsx2("ol", { "data-testid": "words", children: words.map((word, i) => /* @__PURE__ */ jsx2(
+      "li",
+      {
+        "data-testid": `word-${i}`,
+        "data-position": i,
+        children: word
+      },
+      i
+    )) }),
+    copyFailed && /* @__PURE__ */ jsx2("div", { "data-testid": "copy-error", children: "Copy failed \u2014 try again" }),
+    /* @__PURE__ */ jsx2(
+      "button",
+      {
+        "data-testid": "copy-all",
+        onClick: handleCopy,
+        disabled: copyCount === 1,
+        children: copyCount === 1 ? "Copied" : "Copy all"
+      }
+    ),
+    /* @__PURE__ */ jsx2("button", { "data-testid": "dismiss", onClick: handleDismiss, children: "Hide" })
+  ] });
+}
+
+// src/react/SeedPhraseVerify.tsx
+import { useReducer as useReducer4, useCallback as useCallback4, useState as useState5, useEffect as useEffect3, useRef } from "react";
+
+// src/headless/seed-words.ts
+function shuffleWithSeed(items, seed) {
+  const arr = [...items];
+  let currentSeed = seed;
+  function nextRand() {
+    currentSeed = currentSeed * 1664525 + 1013904223 >>> 0;
+    return currentSeed;
+  }
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = nextRand() % (i + 1);
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+function buildVerificationGrid(realWords, gridSize, randomSeed, allWords) {
+  if (gridSize < realWords.length) {
+    throw new Error(
+      `gridSize (${gridSize}) must be >= realWords.length (${realWords.length})`
+    );
+  }
+  const shuffled = shuffleWithSeed(realWords, randomSeed);
+  const realSet = new Set(realWords);
+  const available = allWords.filter((w) => !realSet.has(w));
+  const shuffledDecoys = shuffleWithSeed(available, randomSeed + 1);
+  const needed = gridSize - realWords.length;
+  const decoys = shuffledDecoys.slice(0, needed);
+  const words = [...shuffled, ...decoys];
+  if (words.length !== gridSize) {
+    throw new Error(
+      `Cannot fill grid: wordlist too small (got ${words.length}, need ${gridSize})`
+    );
+  }
+  const positions = /* @__PURE__ */ new Map();
+  words.forEach((w, i) => {
+    const list = positions.get(w);
+    if (list) list.push(i);
+    else positions.set(w, [i]);
+  });
+  const correctIndices = realWords.map((w) => {
+    const list = positions.get(w);
+    if (!list || list.length === 0) {
+      throw new Error(`Internal error: word "${w}" missing from grid`);
+    }
+    return list.shift();
+  });
+  return { words, correctIndices };
+}
+function isGridSelectionCorrect(grid, selected) {
+  if (selected.length !== grid.correctIndices.length) return false;
+  return selected.every((v, i) => v === grid.correctIndices[i]);
+}
+
+// src/headless/verify-flow.ts
+function initVerifyState(realWords, gridSize, randomSeed, allWords) {
+  const grid = buildVerificationGrid(realWords, gridSize, randomSeed, allWords);
+  return {
+    status: "collecting",
+    grid,
+    selected: [],
+    attempts: 0
+  };
+}
+function verifyFlowReducer(state, event) {
+  const { type } = event;
+  if (type === "RESET") {
+    return initVerifyState(
+      event.realWords,
+      event.gridSize,
+      event.randomSeed,
+      event.allWords
+    );
+  }
+  if (state.status === "correct" || state.status === "incorrect") {
+    console.warn(
+      `Cannot ${type} in ${state.status} state \u2014 use RESET to retry`
+    );
+    return state;
+  }
+  if (type === "SELECT") {
+    const { index } = event;
+    const { grid, selected } = state;
+    if (selected.includes(index)) {
+      console.warn(`Index ${index} already selected \u2014 use DESELECT`);
+      return state;
+    }
+    if (index < 0 || index >= grid.words.length) {
+      console.warn(`Index ${index} out of grid bounds`);
+      return state;
+    }
+    return { ...state, selected: [...selected, index] };
+  }
+  if (type === "DESELECT") {
+    const { index } = event;
+    const idx = state.selected.indexOf(index);
+    if (idx === -1) {
+      console.warn(`Index ${index} not selected`);
+      return state;
+    }
+    return {
+      ...state,
+      selected: state.selected.filter((_, i) => i !== idx)
+    };
+  }
+  if (type === "CHECK") {
+    const { grid, selected, attempts } = state;
+    if (selected.length !== grid.correctIndices.length) {
+      console.warn(
+        `Cannot check: selected ${selected.length}, need ${grid.correctIndices.length}`
+      );
+      return state;
+    }
+    const correct = isGridSelectionCorrect(grid, selected);
+    return {
+      ...state,
+      status: correct ? "correct" : "incorrect",
+      attempts: attempts + 1
+    };
+  }
+  console.warn(`Unexpected event ${type} in collecting`);
+  return state;
+}
+
+// src/react/SeedPhraseVerify.tsx
+import { wordlist } from "@me2em/core";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var DEFAULT_GRID_SIZE_OFFSET = 8;
+function SeedPhraseVerify({
+  realWords,
+  gridSize,
+  wordlist: propWordlist,
+  onVerified,
+  onFailed
+}) {
+  const grid = gridSize ?? realWords.length + DEFAULT_GRID_SIZE_OFFSET;
+  const allWords = propWordlist ?? wordlist;
+  const baseSeed = 42;
+  const [state, dispatch] = useReducer4(
+    verifyFlowReducer,
+    {
+      realWords,
+      gridSize: grid,
+      randomSeed: baseSeed,
+      allWords
+    },
+    (params) => initVerifyState(params.realWords, params.gridSize, params.randomSeed, params.allWords)
+  );
+  const [retryCount, setRetryCount] = useState5(0);
+  const { status, grid: gridData, selected } = state;
+  const notifiedRef = useRef(false);
+  const handleSelect = useCallback4(
+    (index) => {
+      if (status === "correct" || status === "incorrect") return;
+      if (selected.length >= gridData.correctIndices.length) return;
+      dispatch({ type: "SELECT", index });
+    },
+    [status, selected.length, gridData.correctIndices.length]
+  );
+  useEffect3(() => {
+    if (notifiedRef.current) return;
+    if (selected.length === gridData.correctIndices.length && selected.length > 0 && status === "collecting") {
+      dispatch({ type: "CHECK" });
+      return;
+    }
+    if (status === "correct") {
+      notifiedRef.current = true;
+      onVerified();
+    } else if (status === "incorrect") {
+      notifiedRef.current = true;
+      onFailed?.(state.attempts);
+    }
+  }, [selected.length, gridData.correctIndices.length, status, state.attempts, onVerified, onFailed]);
+  const handleRetry = () => {
+    notifiedRef.current = false;
+    setRetryCount((c) => c + 1);
+    dispatch({
+      type: "RESET",
+      realWords,
+      gridSize: grid,
+      randomSeed: baseSeed + retryCount + 1,
+      allWords
+    });
+  };
+  return /* @__PURE__ */ jsxs2("div", { children: [
+    /* @__PURE__ */ jsxs2("div", { "data-testid": "progress", children: [
+      "Select word ",
+      selected.length + 1,
+      " of ",
+      realWords.length
+    ] }),
+    /* @__PURE__ */ jsx3("ol", { "data-testid": "grid", children: gridData.words.map((word, i) => {
+      const isSelected = selected.includes(i);
+      const isDisabled = isSelected || status === "correct" || status === "incorrect";
+      return /* @__PURE__ */ jsx3("li", { children: /* @__PURE__ */ jsx3(
+        "button",
+        {
+          "data-testid": `cell-${i}`,
+          "data-word": word,
+          disabled: isDisabled,
+          onClick: () => handleSelect(i),
+          children: word
+        }
+      ) }, i);
+    }) }),
+    status === "incorrect" && /* @__PURE__ */ jsx3("button", { "data-testid": "retry", onClick: handleRetry, children: "Try again" })
+  ] });
+}
+
+// src/react/SeedPhraseImport.tsx
+import { useReducer as useReducer5, useEffect as useEffect4, useRef as useRef2 } from "react";
+
+// src/headless/import-flow.ts
+import { validateSeedPhrase as validateSeedPhrase2 } from "@me2em/core";
+function initImportState(expectedCount) {
+  return {
+    status: "entering",
+    words: Array(expectedCount).fill(null),
+    expectedCount
+  };
+}
+function importFlowReducer(state, event) {
+  const { type } = event;
+  if (type === "INIT") {
+    return initImportState(event.expectedCount);
+  }
+  if (type === "RESET") {
+    return initImportState(state.expectedCount);
+  }
+  if (type === "SET_WORD") {
+    const { position, word } = event;
+    if (position < 0 || position >= state.expectedCount) {
+      console.warn(`SET_WORD: position ${position} out of bounds`);
+      return state;
+    }
+    const normalized = word.toLowerCase().trim();
+    const newWords = [...state.words];
+    newWords[position] = normalized;
+    return { ...state, words: newWords, status: "entering" };
+  }
+  if (type === "CLEAR_WORD") {
+    const { position } = event;
+    if (position < 0 || position >= state.expectedCount) {
+      console.warn(`CLEAR_WORD: position ${position} out of bounds`);
+      return state;
+    }
+    const newWords = [...state.words];
+    newWords[position] = null;
+    return { ...state, words: newWords, status: "entering" };
+  }
+  if (type === "CHECK") {
+    const { words } = state;
+    const nullIdx = words.findIndex((w) => w === null);
+    if (nullIdx !== -1) {
+      return {
+        ...state,
+        status: "invalid"
+      };
+    }
+    const result = validateSeedPhrase2(words);
+    return {
+      ...state,
+      status: result.isValid ? "valid" : "invalid"
+    };
+  }
+  console.warn(`Unexpected event ${type} in import-flow`);
+  return state;
+}
+
+// src/react/SeedPhraseImport.tsx
+import { wordlist as wordlist2 } from "@me2em/core";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function SeedPhraseImport({
+  expectedCount: propCount,
+  wordlist: propWordlist,
+  onImported
+}) {
+  const allWords = propWordlist ?? wordlist2;
+  const [state, dispatch] = useReducer5(
+    importFlowReducer,
+    { expectedCount: propCount ?? 12 },
+    (params) => initImportState(params.expectedCount)
+  );
+  const count = state.expectedCount;
+  const prevStatusRef = useRef2(state.status);
+  const lastImportedRef = useRef2(null);
+  useEffect4(() => {
+    dispatch({ type: "CHECK" });
+  }, [state.words]);
+  useEffect4(() => {
+    const prevStatus = prevStatusRef.current;
+    prevStatusRef.current = state.status;
+    if (state.status === "valid" && prevStatus !== "valid") {
+      const key = state.words.join("\0");
+      if (lastImportedRef.current !== key) {
+        lastImportedRef.current = key;
+        onImported(state.words);
+      }
+    }
+  }, [state.status, state.words, onImported]);
+  const handleCountChange = (n) => {
+    dispatch({ type: "INIT", expectedCount: n });
+  };
+  const handleWordChange = (position, value) => {
+    dispatch({ type: "SET_WORD", position, word: value });
+  };
+  const isWordInvalid = (position) => {
+    if (state.status !== "invalid" && state.status !== "valid") return false;
+    const word = state.words[position];
+    if (word === null) return false;
+    return !allWords.includes(word);
+  };
+  const isImportEnabled = state.status === "valid";
+  return /* @__PURE__ */ jsxs3("div", { children: [
+    /* @__PURE__ */ jsxs3("div", { children: [
+      /* @__PURE__ */ jsx4(
+        "button",
+        {
+          "data-testid": "count-12",
+          onClick: () => handleCountChange(12),
+          disabled: count === 12,
+          children: "12 words"
+        }
+      ),
+      /* @__PURE__ */ jsx4(
+        "button",
+        {
+          "data-testid": "count-24",
+          onClick: () => handleCountChange(24),
+          disabled: count === 24,
+          children: "24 words"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx4("div", { "data-testid": "inputs", children: Array.from({ length: count }, (_, i) => /* @__PURE__ */ jsx4(
+      "input",
+      {
+        "data-testid": `word-${i}`,
+        "aria-label": `Word ${i + 1}`,
+        value: state.words[i] ?? "",
+        onChange: (e) => handleWordChange(i, e.target.value),
+        "data-invalid": isWordInvalid(i) ? "true" : void 0
+      },
+      i
+    )) }),
+    /* @__PURE__ */ jsx4(
+      "button",
+      {
+        "data-testid": "import",
+        disabled: !isImportEnabled,
+        onClick: () => dispatch({ type: "CHECK" }),
+        children: "Import"
+      }
+    )
+  ] });
+}
+
+// src/react/PassphraseInput.tsx
+import { useCallback as useCallback6 } from "react";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function PassphraseInput({
+  onPassphraseChange,
+  showWarnings = true
+}) {
+  const handleChange = useCallback6(
+    (e) => {
+      const value = e.target.value.normalize("NFKC");
+      onPassphraseChange(value);
+    },
+    [onPassphraseChange]
+  );
+  return /* @__PURE__ */ jsxs4("div", { children: [
+    /* @__PURE__ */ jsx5(
+      "input",
+      {
+        type: "password",
+        "data-testid": "passphrase",
+        "aria-label": "BIP39 passphrase",
+        onChange: handleChange
+      }
+    ),
+    showWarnings && /* @__PURE__ */ jsx5("div", { "data-testid": "warning", children: "Passphrase is case-sensitive and NOT recoverable. A different passphrase silently derives a different wallet." })
+  ] });
+}
+
+// src/react/useIdentityContext.ts
+import { useState as useState7, useCallback as useCallback7, useEffect as useEffect5, useRef as useRef3 } from "react";
+function publicKeyToId(publicKey) {
+  return Array.from(publicKey).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function useIdentityContext(storage) {
+  const { identity } = useMe2emContext();
+  const [context, setContext] = useState7(null);
+  const [isLoaded, setIsLoaded] = useState7(false);
+  const [error, setError] = useState7(null);
+  const prevIdentityIdRef = useRef3(null);
+  useEffect5(() => {
+    let cancelled = false;
+    if (!identity) {
+      setContext(null);
+      setIsLoaded(true);
+      setError(null);
+      return;
+    }
+    const identityId = publicKeyToId(identity.getPublicKey());
+    if (prevIdentityIdRef.current !== null && prevIdentityIdRef.current !== identityId) {
+      storage.close().catch(() => {
+      });
+    }
+    prevIdentityIdRef.current = identityId;
+    storage.openAndLoad(identityId).then((data) => {
+      if (cancelled) return;
+      setContext(data);
+      setIsLoaded(true);
+      setError(null);
+    }).catch((err) => {
+      if (cancelled) return;
+      setError(err instanceof Error ? err.message : String(err));
+      setIsLoaded(true);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [identity, storage]);
+  const save = useCallback7(async (data) => {
+    await storage.save(data);
+    setContext(data);
+  }, [storage]);
+  const clear = useCallback7(async () => {
+    await storage.clear();
+    setContext(null);
+  }, [storage]);
+  const refresh = useCallback7(async () => {
+    if (!identity) return;
+    const identityId = publicKeyToId(identity.getPublicKey());
+    const data = await storage.openAndLoad(identityId);
+    setContext(data);
+  }, [identity, storage]);
+  return { context, isLoaded, error, save, clear, refresh };
+}
+
+// src/react/useSession.ts
+import { useState as useState8, useEffect as useEffect6, useCallback as useCallback8, useRef as useRef4 } from "react";
+import { Session } from "@me2em/core";
+function useSession(handle, options, autoRenew = true) {
+  const { identity } = useMe2emContext();
+  const [session, setSession] = useState8(null);
+  const [isLoaded, setIsLoaded] = useState8(false);
+  const [error, setError] = useState8(null);
+  const timerRef = useRef4(null);
+  const optionsRef = useRef4(options);
+  const mountedRef = useRef4(true);
+  optionsRef.current = options;
+  const clearTimer = useCallback8(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+  }, []);
+  useEffect6(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      clearTimer();
+    };
+  }, [clearTimer]);
+  const renew = useCallback8(() => {
+    clearTimer();
+    const opts = optionsRef.current;
+    if (!handle) {
+      if (!mountedRef.current) return;
+      setSession(null);
+      setIsLoaded(true);
+      setError(null);
+      return;
+    }
+    Session.create(handle, {
+      audience: opts.audience,
+      scopes: opts.scopes,
+      ttl: opts.ttl
+    }).then((s) => {
+      if (!mountedRef.current) return;
+      setSession(s);
+      setIsLoaded(true);
+      setError(null);
+      if (autoRenew) {
+        const halfLife = Math.floor((s.expiresAt * 1e3 - Date.now()) / 2);
+        if (halfLife > 0) {
+          timerRef.current = setTimeout(() => {
+            renew();
+          }, Math.max(halfLife, 1e3));
+        }
+      }
+    }).catch((err) => {
+      if (!mountedRef.current) return;
+      setSession(null);
+      setIsLoaded(true);
+      setError(err instanceof Error ? err.message : String(err));
+    });
+  }, [handle, autoRenew, clearTimer]);
+  useEffect6(() => {
+    if (mountedRef.current) {
+      renew();
+    }
+  }, [handle, renew]);
+  return {
+    session,
+    isLoaded,
+    error,
+    isExpired: session ? session.isExpired() : false,
+    renew
+  };
+}
+
+// src/headless/index.ts
+var headless_exports = {};
+__export(headless_exports, {
+  IdentityContextIDBStorage: () => IdentityContextIDBStorage,
+  buildVerificationGrid: () => buildVerificationGrid,
+  decryptContext: () => decryptContext,
+  deriveCacheKey: () => deriveCacheKey,
+  displayFlowReducer: () => displayFlowReducer,
+  encryptContext: () => encryptContext,
+  identityFlowReducer: () => identityFlowReducer,
+  importFlowReducer: () => importFlowReducer,
+  initImportState: () => initImportState,
+  initVerifyState: () => initVerifyState,
+  initialDisplayState: () => initialDisplayState,
+  initialIdentityFlowState: () => initialIdentityFlowState,
+  isGridSelectionCorrect: () => isGridSelectionCorrect,
+  shuffleWithSeed: () => shuffleWithSeed,
+  verifyFlowReducer: () => verifyFlowReducer
+});
+
+// src/headless/context-crypto.ts
+function toB64(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromB64(s) {
+  let base64 = s.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4 !== 0) {
+    base64 += "=";
+  }
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function deriveCacheKey(loginMaterial, salt) {
+  const base = await crypto.subtle.importKey(
+    "raw",
+    loginMaterial,
+    "HKDF",
+    false,
+    ["deriveBits"]
+  );
+  const bits = await crypto.subtle.deriveBits(
+    {
+      name: "HKDF",
+      hash: "SHA-256",
+      salt,
+      info: new TextEncoder().encode("me2em/cache-wrap/v1")
+    },
+    base,
+    256
+  );
+  return crypto.subtle.importKey(
+    "raw",
+    bits,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function encryptContext(key, data) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const salt = crypto.getRandomValues(new Uint8Array(32));
+  const pt = new TextEncoder().encode(JSON.stringify(data));
+  const ct = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    pt
+  );
+  return {
+    v: 1,
+    salt: toB64(salt),
+    iv: toB64(iv),
+    ct: toB64(new Uint8Array(ct))
+  };
+}
+async function decryptContext(key, envelope) {
+  if (envelope.v !== 1) throw new Error("Unsupported envelope version");
+  const pt = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv: fromB64(envelope.iv) },
+    key,
+    fromB64(envelope.ct)
+  );
+  return JSON.parse(new TextDecoder().decode(pt));
+}
+
+// src/headless/identity-context-storage.ts
+var DB_NAME_PREFIX = "me2em_";
+var STORE_NAME = "context";
+var KEYS_STORE_NAME = "cryptoKeys";
+var CACHE_KEY = "cache";
+function hashToHex(data) {
+  const hexParts = [];
+  for (const byte of data) {
+    hexParts.push(byte.toString(16).padStart(2, "0"));
+  }
+  return hexParts.join("");
+}
+async function sha256Hex(data) {
+  const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  const digest = await crypto.subtle.digest("SHA-256", buffer);
+  return hashToHex(new Uint8Array(digest));
+}
+async function dbNameForIdentity(identityId) {
+  const hash = await sha256Hex(new TextEncoder().encode(identityId));
+  return DB_NAME_PREFIX + hash.slice(0, 16);
+}
+var IdentityContextIDBStorage = class {
+  db = null;
+  currentIdentityId = null;
+  cacheKey = null;
+  async getDb() {
+    if (!this.db) {
+      throw new Error("Storage not opened \u2014 call open() first");
+    }
+    return this.db;
+  }
+  async open(identityId) {
+    if (this.currentIdentityId !== null && this.currentIdentityId !== identityId) {
+      await this.close();
+    }
+    this.currentIdentityId = identityId;
+    const name = await dbNameForIdentity(identityId);
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(name, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          db.createObjectStore(STORE_NAME, { keyPath: "key" });
+        }
+        if (!db.objectStoreNames.contains(KEYS_STORE_NAME)) {
+          db.createObjectStore(KEYS_STORE_NAME, { keyPath: "key" });
+        }
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+      request.onerror = () => {
+        reject(new Error("IndexedDB open failed: " + request.error?.message));
+      };
+    });
+  }
+  async openAndLoad(identityId) {
+    await this.open(identityId);
+    const key = this.cacheKey ?? await this.loadPersistedKey();
+    if (!key) {
+      return null;
+    }
+    this.cacheKey = key;
+    return this.load();
+  }
+  async save(data) {
+    const key = this.cacheKey;
+    if (!key) {
+      throw new Error("No cache key set \u2014 call setCacheKey before save");
+    }
+    const envelope = await encryptContext(key, data);
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      const store = tx.objectStore(STORE_NAME);
+      store.put({ key: CACHE_KEY, envelope });
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(new Error("Save failed: " + tx.error?.message));
+    });
+  }
+  async load() {
+    const db = await this.getDb();
+    const key = this.cacheKey;
+    if (!key) {
+      return null;
+    }
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readonly");
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.get(CACHE_KEY);
+      request.onsuccess = () => {
+        const record = request.result;
+        if (!record || !record.envelope) {
+          resolve(null);
+          return;
+        }
+        decryptContext(key, record.envelope).then((data) => {
+          if (data.identityId !== this.currentIdentityId) {
+            resolve(null);
+            return;
+          }
+          resolve(data);
+        }).catch(() => {
+          resolve(null);
+        });
+      };
+      request.onerror = () => reject(new Error("Load failed: " + request.error?.message));
+    });
+  }
+  async clear() {
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      const store = tx.objectStore(STORE_NAME);
+      store.delete(CACHE_KEY);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(new Error("Clear failed: " + tx.error?.message));
+    });
+  }
+  async close() {
+    const db = this.db;
+    this.db = null;
+    this.currentIdentityId = null;
+    this.cacheKey = null;
+    if (db) {
+      db.close();
+    }
+  }
+  setCacheKey(key) {
+    this.cacheKey = key;
+  }
+  getCacheKey() {
+    return this.cacheKey;
+  }
+  async persistCacheKey() {
+    const key = this.cacheKey;
+    if (!key) {
+      throw new Error("No cache key to persist \u2014 call setCacheKey first");
+    }
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(KEYS_STORE_NAME, "readwrite");
+      const store = tx.objectStore(KEYS_STORE_NAME);
+      store.put({ key: "cache", cryptoKey: key });
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(new Error("persistCacheKey failed: " + tx.error?.message));
+    });
+  }
+  async loadPersistedKey() {
+    const db = this.db;
+    if (!db) {
+      return null;
+    }
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(KEYS_STORE_NAME, "readonly");
+      const store = tx.objectStore(KEYS_STORE_NAME);
+      const request = store.get("cache");
+      request.onsuccess = () => {
+        const record = request.result;
+        if (!record || !record.cryptoKey) {
+          resolve(null);
+          return;
+        }
+        resolve(record.cryptoKey);
+      };
+      request.onerror = () => {
+        resolve(null);
+      };
+    });
+  }
+};
+export {
+  Me2emProvider,
+  PassphraseInput,
+  SeedPhraseDisplay,
+  SeedPhraseImport,
+  SeedPhraseVerify,
+  headless_exports as headless,
+  useCreateIdentity,
+  useHandle,
+  useIdentityContext,
+  useImportSeed,
+  useMe2emContext,
+  useSession,
+  useSubHandle
+};
+//# sourceMappingURL=index.js.map