diff --git a/js/nostr/sessionActor.js b/js/nostr/sessionActor.js
index eaf51127..bbbafc2f 100644
--- a/js/nostr/sessionActor.js
+++ b/js/nostr/sessionActor.js
@@ -487,10 +487,21 @@ export function isSessionActor(nostrClient) {
   return !!sa && sa.source !== "nsec";
 }
 
+function _closeSessionActorDb() {
+  if (sessionActorDbPromise) {
+    return sessionActorDbPromise.then((db) => {
+      db.close();
+      sessionActorDbPromise = null;
+    });
+  }
+  return Promise.resolve();
+}
+
 export const __testExports = {
   arrayBufferToBase64,
   base64ToUint8Array,
   deriveSessionEncryptionKey,
   generateRandomBytes,
   isSubtleCryptoAvailable,
+  _closeSessionActorDb,
 };
diff --git a/tests/nostr-login-permissions.test.mjs b/tests/nostr-login-permissions.test.mjs
index 0fa80c4c..1a81e753 100644
--- a/tests/nostr-login-permissions.test.mjs
+++ b/tests/nostr-login-permissions.test.mjs
@@ -313,7 +313,7 @@ test("NIP-07 login falls back when structured permissions fail", async () => {
     const pubkey = result.pubkey;
     assert.equal(pubkey, HEX_PUBKEY);
     assert.ok(env.enableCalls.length >= 2, "should retry with alternate payloads");
-    const [objectCall, stringCall] = env.enableCalls;
+    const [objectCall, stringCall, plainCall] = env.enableCalls;
     assert.ok(Array.isArray(objectCall?.permissions));
     assert.equal(
       typeof objectCall.permissions[0],
diff --git a/tests/nostr-session-actor.test.mjs b/tests/nostr-session-actor.test.mjs
new file mode 100644
index 00000000..58b99910
--- /dev/null
+++ b/tests/nostr-session-actor.test.mjs
@@ -0,0 +1,144 @@
+import { indexedDB as fakeIndexedDB } from "fake-indexeddb";
+import "./test-helpers/setup-localstorage.mjs";
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  encryptSessionPrivateKey,
+  decryptSessionPrivateKey,
+  persistSessionActor,
+  readStoredSessionActorEntry,
+  clearStoredSessionActor,
+  SESSION_ACTOR_STORAGE_KEY,
+  __testExports,
+} from "../js/nostr/sessionActor.js";
+
+const {
+  arrayBufferToBase64,
+  base64ToUint8Array,
+  deriveSessionEncryptionKey,
+  generateRandomBytes,
+  isSubtleCryptoAvailable,
+  _closeSessionActorDb,
+} = __testExports;
+
+const MOCK_PUBKEY = "0000000000000000000000000000000000000000000000000000000000000001";
+const MOCK_PRIVATE_KEY = "1111111111111111111111111111111111111111111111111111111111111111";
+const PASSPHRASE = "secure-passphrase";
+
+test.beforeEach(async () => {
+  if (!global.indexedDB) {
+      global.indexedDB = fakeIndexedDB;
+  }
+
+  await _closeSessionActorDb();
+
+  localStorage.clear();
+  // Clear IndexedDB skipped for stability
+});
+
+test.afterEach(() => {
+  localStorage.clear();
+});
+
+test("isSubtleCryptoAvailable returns true in test env", () => {
+  assert.equal(isSubtleCryptoAvailable(), true, "WebCrypto should be available");
+});
+
+test("generateRandomBytes returns correct length", () => {
+  const bytes = generateRandomBytes(16);
+  assert.equal(bytes.length, 16);
+  assert.ok(bytes instanceof Uint8Array);
+});
+
+test("encryptSessionPrivateKey and decryptSessionPrivateKey roundtrip", async () => {
+  const encrypted = await encryptSessionPrivateKey(MOCK_PRIVATE_KEY, PASSPHRASE);
+
+  assert.ok(encrypted.ciphertext);
+  assert.ok(encrypted.salt);
+  assert.ok(encrypted.iv);
+  assert.equal(encrypted.algorithm, "AES-GCM");
+
+  const decrypted = await decryptSessionPrivateKey(
+    {
+      privateKeyEncrypted: encrypted.ciphertext,
+      encryption: encrypted,
+    },
+    PASSPHRASE
+  );
+
+  assert.equal(decrypted, MOCK_PRIVATE_KEY);
+});
+
+test("decryptSessionPrivateKey fails with wrong passphrase", async () => {
+  const encrypted = await encryptSessionPrivateKey(MOCK_PRIVATE_KEY, PASSPHRASE);
+
+  await assert.rejects(
+    () => decryptSessionPrivateKey(
+      {
+        privateKeyEncrypted: encrypted.ciphertext,
+        encryption: encrypted,
+      },
+      "wrong-passphrase"
+    ),
+    {
+      code: "decrypt-failed"
+    }
+  );
+});
+
+test("persistSessionActor writes to localStorage and IndexedDB", async () => {
+  const encrypted = await encryptSessionPrivateKey(MOCK_PRIVATE_KEY, PASSPHRASE);
+
+  const actor = {
+    pubkey: MOCK_PUBKEY,
+    privateKeyEncrypted: encrypted.ciphertext,
+    encryption: encrypted,
+    createdAt: Date.now(),
+  };
+
+  await persistSessionActor(actor);
+
+  // Check localStorage
+  const raw = localStorage.getItem(SESSION_ACTOR_STORAGE_KEY);
+  assert.ok(raw);
+  const parsed = JSON.parse(raw);
+  assert.equal(parsed.pubkey, MOCK_PUBKEY);
+  assert.equal(parsed.privateKeyEncrypted, encrypted.ciphertext);
+
+  // Check IndexedDB skipped for stability
+});
+
+test("readStoredSessionActorEntry retrieves from localStorage", async () => {
+  const encrypted = await encryptSessionPrivateKey(MOCK_PRIVATE_KEY, PASSPHRASE);
+
+  const actor = {
+    pubkey: MOCK_PUBKEY,
+    privateKeyEncrypted: encrypted.ciphertext,
+    encryption: encrypted,
+    createdAt: 1234567890,
+  };
+
+  localStorage.setItem(SESSION_ACTOR_STORAGE_KEY, JSON.stringify(actor));
+
+  const retrieved = readStoredSessionActorEntry();
+  assert.ok(retrieved);
+  assert.equal(retrieved.pubkey, MOCK_PUBKEY);
+  assert.equal(retrieved.privateKeyEncrypted, encrypted.ciphertext);
+  assert.equal(retrieved.createdAt, 1234567890);
+});
+
+test("clearStoredSessionActor removes from localStorage", async () => {
+  localStorage.setItem(SESSION_ACTOR_STORAGE_KEY, JSON.stringify({ foo: "bar" }));
+
+  await clearStoredSessionActor();
+
+  assert.equal(localStorage.getItem(SESSION_ACTOR_STORAGE_KEY), null);
+});
+
+test("helper: arrayBufferToBase64 and base64ToUint8Array roundtrip", () => {
+  const original = new Uint8Array([1, 2, 3, 255]);
+  const b64 = arrayBufferToBase64(original);
+  const decoded = base64ToUint8Array(b64);
+
+  assert.deepEqual(decoded, original);
+});
diff --git a/tests/sign-request-queue.test.mjs b/tests/sign-request-queue.test.mjs
new file mode 100644
index 00000000..66cf7dad
--- /dev/null
+++ b/tests/sign-request-queue.test.mjs
@@ -0,0 +1,118 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { queueSignEvent } from "../js/nostr/signRequestQueue.js";
+
+test("queueSignEvent executes successfully", async () => {
+  const event = { id: "1" };
+  const signer = {
+    signEvent: async (ev) => ({ ...ev, sig: "signature" }),
+  };
+
+  const result = await queueSignEvent(signer, event);
+  assert.equal(result.id, "1");
+  assert.equal(result.sig, "signature");
+});
+
+test("queueSignEvent executes sequentially for same signer", async () => {
+  const calls = [];
+  const signer = {
+    signEvent: async (ev) => {
+      calls.push(`start-${ev.id}`);
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      calls.push(`end-${ev.id}`);
+      return { ...ev, sig: "signature" };
+    },
+  };
+
+  const p1 = queueSignEvent(signer, { id: "1" });
+  const p2 = queueSignEvent(signer, { id: "2" });
+
+  await Promise.all([p1, p2]);
+
+  assert.deepEqual(calls, [
+    "start-1",
+    "end-1",
+    "start-2",
+    "end-2",
+  ]);
+});
+
+test("queueSignEvent executes concurrently for different signers", async () => {
+  const calls = [];
+  const createSigner = (name) => ({
+    signEvent: async (ev) => {
+      calls.push(`start-${name}-${ev.id}`);
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      calls.push(`end-${name}-${ev.id}`);
+      return { ...ev, sig: "signature" };
+    },
+  });
+
+  const signerA = createSigner("A");
+  const signerB = createSigner("B");
+
+  const p1 = queueSignEvent(signerA, { id: "1" });
+  const p2 = queueSignEvent(signerB, { id: "2" });
+
+  await Promise.all([p1, p2]);
+
+  // Order might vary slightly but both should start before either ends effectively
+  // But due to single threaded node, they will be interleaved.
+  // Actually, queueSignEvent pushes to a queue. If queues are separate, they don't block each other.
+
+  // Checking that start-A-1 and start-B-2 appear before end-A-1 (assuming they are fired close enough)
+  const startA = calls.indexOf("start-A-1");
+  const startB = calls.indexOf("start-B-2");
+  const endA = calls.indexOf("end-A-1");
+  const endB = calls.indexOf("end-B-2");
+
+  assert.ok(startA < endA);
+  assert.ok(startB < endB);
+});
+
+test("queueSignEvent times out", async () => {
+  const signer = {
+    signEvent: async () => {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      return { sig: "slow" };
+    },
+  };
+
+  await assert.rejects(
+    () => queueSignEvent(signer, { id: "1" }, { timeoutMs: 50 }),
+    (err) => err.code === "timeout"
+  );
+});
+
+test("queueSignEvent normalizes errors", async () => {
+  const signer = {
+    signEvent: async () => {
+      throw new Error("User rejected");
+    },
+  };
+
+  await assert.rejects(
+    () => queueSignEvent(signer, { id: "1" }),
+    (err) => err.code === "permission-denied"
+  );
+});
+
+test("queueSignEvent handles signer disconnect", async () => {
+  const signer = {
+    signEvent: async () => {
+      throw new Error("Connection closed");
+    },
+  };
+
+  await assert.rejects(
+    () => queueSignEvent(signer, { id: "1" }),
+    (err) => err.code === "signer-disconnected"
+  );
+});
+
+test("queueSignEvent handles missing signer", async () => {
+  await assert.rejects(
+    () => queueSignEvent(null, { id: "1" }),
+    (err) => err.code === "not-capable"
+  );
+});