@synonymdev/pubky 0.14.0 → 0.16.0

package/index.cjs

@@ -9,6 +9,7 @@ const PUBKY_SESSIONS_DB_NAME = "pubky-auth";
 const PUBKY_SESSIONS_DB_VERSION = 1;
 const PUBKY_SESSIONS_STORE_NAME = "storedSessions";
 const PUBKY_SESSIONS_DELEGATED_KEYS_STORE_NAME = "delegatedGrantKeys";
+const PUBKY_APPROVAL_SESSION_VERSION = "pubky-session-v2";
 
 /** Assert that IndexedDB is available for browser session persistence. */
 function requireIndexedDb() {
@@ -53,42 +54,32 @@ function openSessionStoreDb() {
 }
 
 /**
- * Run an IndexedDB operation against the stored-session object store.
+ * Run an IndexedDB operation across session records and browser keys.
  *
- * The callback receives the object store and returns a request. This wrapper
+ * The callback receives the transaction and returns a request. This wrapper
  * resolves only after the transaction commits, not when the request succeeds.
  */
-async function withSessionStore(mode, operation) {
+async function withSessionStores(mode, operation) {
   const db = await openSessionStoreDb();
   try {
     return await new Promise((resolve, reject) => {
-      const tx = db.transaction(PUBKY_SESSIONS_STORE_NAME, mode);
-      const store = tx.objectStore(PUBKY_SESSIONS_STORE_NAME);
+      const tx = db.transaction(
+        [PUBKY_SESSIONS_STORE_NAME, PUBKY_SESSIONS_DELEGATED_KEYS_STORE_NAME], mode,
+      );
       let result;
-      let settled = false;
-
-      function fail(error) {
-        if (settled) return;
-        settled = true;
-        reject(error);
-      }
-
       try {
-        const request = operation(store);
+        const request = operation(tx);
         request.onsuccess = () => {
           result = request.result;
         };
-        request.onerror = () => fail(request.error ?? new Error("Pubky session store request failed."));
+        request.onerror = () => reject(request.error ?? new Error("Pubky session store request failed."));
       } catch (error) {
-        fail(error);
+        tx.abort();
+        reject(error);
       }
-      tx.onerror = () => fail(tx.error ?? new Error("Pubky session store transaction failed."));
-      tx.onabort = () => fail(tx.error ?? new Error("Pubky session store transaction aborted."));
-      tx.oncomplete = () => {
-        if (settled) return;
-        settled = true;
-        resolve(result);
-      };
+      tx.onerror = () => reject(tx.error ?? new Error("Pubky session store transaction failed."));
+      tx.onabort = () => reject(tx.error ?? new Error("Pubky session store transaction aborted."));
+      tx.oncomplete = () => resolve(result);
     });
   } finally {
     db.close();
@@ -99,6 +90,7 @@ async function withSessionStore(mode, operation) {
 async function __pubkySessionStoreIsAvailable() {
   if (!globalThis.indexedDB) return false;
   try {
+    if (!globalThis.navigator?.locks) return false;
     const db = await openSessionStoreDb();
     db.close();
     return true;
@@ -108,20 +100,48 @@ async function __pubkySessionStoreIsAvailable() {
 }
 
 /** Persist or replace a browser session record. */
-async function __pubkySessionStorePut(record) {
+async function __pubkySessionStorePut(record, lease) {
   requireIndexedDb();
   try {
-    await withSessionStore("readwrite", (store) => store.put(record));
+    const previous = await __pubkySessionStoreGet(record.id);
+    if (previous?.version === PUBKY_APPROVAL_SESSION_VERSION && record.version !== previous.version) {
+      throw new Error("Cannot replace a stored approval with an authentication-only record.");
+    }
+    const stored = { ...record };
+    if (previous?.sharedSession) stored.sharedSession = previous.sharedSession;
+    await withSessionStores("readwrite", tx => {
+      const held = requireSessionLease(lease, true);
+      if (held.id !== record.id || held.homeserver !== record.homeserver) {
+        throw new Error("Session record does not match its browser lock.");
+      }
+      return tx.objectStore(PUBKY_SESSIONS_STORE_NAME).put(stored);
+    });
   } catch (error) {
     throw contextualSessionStoreError("Saving Pubky session failed.", error);
   }
 }
 
+function sessionMetadata(record) {
+  if (!record) return record;
+  const { version, id, storageMode, publicKey, homeserver, grantId, clientId,
+    capabilities, grantExpiresAt, createdAt } = record;
+  return { version, id, storageMode, publicKey, homeserver, grantId, clientId,
+    capabilities, grantExpiresAt, createdAt,
+    hasStoredApproval: record.signedApproval !== undefined,
+  };
+}
+
+async function __pubkySessionStoreMetadata(id) {
+  return sessionMetadata(await __pubkySessionStoreGet(id));
+}
+
 /** Load a browser session record by id. */
 async function __pubkySessionStoreGet(id) {
   requireIndexedDb();
   try {
-    return await withSessionStore("readonly", (store) => store.get(id));
+    return await withSessionStores("readonly", tx =>
+      tx.objectStore(PUBKY_SESSIONS_STORE_NAME).get(id),
+    );
   } catch (error) {
     throw contextualSessionStoreError("Reading Pubky session failed.", error);
   }
@@ -131,71 +151,139 @@ async function __pubkySessionStoreGet(id) {
 async function __pubkySessionStoreList() {
   if (!globalThis.indexedDB) return [];
   try {
-    return (await withSessionStore("readonly", (store) => store.getAll())) ?? [];
+    const records = await withSessionStores("readonly", tx =>
+      tx.objectStore(PUBKY_SESSIONS_STORE_NAME).getAll(),
+    );
+    return records.map(sessionMetadata);
   } catch (_error) {
     return [];
   }
 }
 
-/** Remove one browser session record by id. */
-async function __pubkySessionStoreDelete(id) {
-  requireIndexedDb();
-  try {
-    await withSessionStore("readwrite", (store) => store.delete(id));
-  } catch (error) {
-    throw contextualSessionStoreError("Removing Pubky session failed.", error);
-  }
-}
-
-/**
- * Clear saved session records and the delegated keys referenced by those records.
- *
- * Delegated keys not referenced by the supplied ids are intentionally preserved,
- * because they may belong to pending or unsaved grant flows.
- */
-async function __pubkySessionStoreClear(delegatedKeyIds) {
+/** Clear saved sessions and their keys, or every key when clearing all auth state. */
+async function clearSessionStore(allKeys = false) {
   requireIndexedDb();
   const db = await openSessionStoreDb();
   try {
     await new Promise((resolve, reject) => {
       const tx = db.transaction(
-        [PUBKY_SESSIONS_STORE_NAME, PUBKY_SESSIONS_DELEGATED_KEYS_STORE_NAME],
-        "readwrite",
+        [PUBKY_SESSIONS_STORE_NAME, PUBKY_SESSIONS_DELEGATED_KEYS_STORE_NAME], "readwrite",
       );
       const sessions = tx.objectStore(PUBKY_SESSIONS_STORE_NAME);
       const keys = tx.objectStore(PUBKY_SESSIONS_DELEGATED_KEYS_STORE_NAME);
-      sessions.clear();
-      for (const keyId of new Set(delegatedKeyIds ?? [])) {
-        keys.delete(keyId);
-      }
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error ?? new Error("Clearing Pubky session store failed."));
-      tx.onabort = () => reject(tx.error ?? new Error("Clearing Pubky session store aborted."));
+      const records = sessions.getAll();
+      records.onsuccess = () => {
+        try {
+          if (allKeys) keys.clear();
+          else for (const record of records.result) {
+            if (record.storageMode === "delegated") keys.delete(JSON.parse(record.credential).keyId);
+          }
+          sessions.clear();
+        } catch (error) { tx.abort(); reject(error); }
+      };
+      tx.oncomplete = resolve;
+      tx.onerror = tx.onabort = () => reject(tx.error ?? new Error("Clearing browser sessions failed."));
     });
-  } finally {
-    db.close();
+  } finally { db.close(); }
+}
+
+const SESSION_STORE_LOCK = "pubky-session-store";
+const sessionLeases = new Map();
+let nextSessionLease = 0;
+const sessionChannel = typeof indexedDB !== "undefined" && typeof BroadcastChannel === "function"
+  ? new BroadcastChannel("pubky-session-store") : null;
+function notifySessionChange(detail) {
+  if (typeof globalThis.dispatchEvent === "function") {
+    globalThis.dispatchEvent(new CustomEvent("pubky-session-changed", { detail }));
   }
 }
+if (sessionChannel) sessionChannel.onmessage = event => notifySessionChange(event.data);
+function sessionChanged(id, action) {
+  const detail = { id, action };
+  notifySessionChange(detail);
+  sessionChannel?.postMessage(detail);
+}
 
-/** Clear all browser auth records, including all delegated key handles. */
-async function __pubkySessionStoreClearAll() {
-  requireIndexedDb();
+function __pubkySessionAcquire(id, homeserver, exclusive) {
+  if (!globalThis.navigator?.locks) throw new Error("Browser sessions require Web Locks in a secure context.");
+  const token = ++nextSessionLease;
+  const abort = new AbortController();
+  let release, ready, failed;
+  const held = new Promise(resolve => { release = resolve; });
+  const waiting = new Promise((resolve, reject) => { ready = resolve; failed = reject; });
+  // Cancellation can drop the Rust future before it starts awaiting this promise.
+  waiting.catch(() => {});
+  const lease = { id, homeserver, exclusive, abort, release, waiting, active: false };
+  sessionLeases.set(token, lease);
+  navigator.locks.request(SESSION_STORE_LOCK, { mode: "shared", signal: abort.signal }, () =>
+    navigator.locks.request(`pubky-shared-session:${homeserver}:${id}`, {
+      mode: exclusive ? "exclusive" : "shared", signal: abort.signal,
+    }, async () => {
+      lease.active = true;
+      ready();
+      await held;
+    })
+  ).catch(failed);
+  return token;
+}
+function __pubkySessionWait(token) {
+  return sessionLeases.get(token).waiting;
+}
+function __pubkySessionRelease(token) {
+  const lease = sessionLeases.get(token);
+  if (!lease) return;
+  lease.active = false;
+  lease.abort.abort();
+  lease.release();
+  sessionLeases.delete(token);
+}
+function requireSessionLease(token, write = false) {
+  const lease = sessionLeases.get(token);
+  if (!lease?.active || (write && !lease.exclusive)) throw new Error("Browser session lock was released.");
+  return lease;
+}
+async function __pubkySharedSessionLoad(token) {
+  const lease = requireSessionLease(token);
+  const record = await __pubkySessionStoreGet(lease.id);
+  if (record && record.homeserver !== lease.homeserver) throw new Error("Stored session homeserver changed.");
+  return record?.sharedSession;
+}
+async function __pubkySharedSessionStore(token, sharedSession) {
+  const lease = requireSessionLease(token, true);
+  const record = await __pubkySessionStoreGet(lease.id);
+  if (!record || record.homeserver !== lease.homeserver) throw new Error("Browser session was removed or changed.");
+  await withSessionStores("readwrite", tx => {
+    requireSessionLease(token, true);
+    return tx.objectStore(PUBKY_SESSIONS_STORE_NAME).put({ ...record, sharedSession });
+  });
+}
+async function __pubkySharedSessionRemove(token) {
+  const lease = requireSessionLease(token, true);
+  const record = await __pubkySessionStoreGet(lease.id);
+  if (!record) return;
   const db = await openSessionStoreDb();
   try {
+    requireSessionLease(token, true);
     await new Promise((resolve, reject) => {
-      const tx = db.transaction(
-        [PUBKY_SESSIONS_STORE_NAME, PUBKY_SESSIONS_DELEGATED_KEYS_STORE_NAME],
-        "readwrite",
-      );
-      tx.objectStore(PUBKY_SESSIONS_STORE_NAME).clear();
-      tx.objectStore(PUBKY_SESSIONS_DELEGATED_KEYS_STORE_NAME).clear();
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error ?? new Error("Clearing Pubky auth store failed."));
-      tx.onabort = () => reject(tx.error ?? new Error("Clearing Pubky auth store aborted."));
+      const tx = db.transaction([PUBKY_SESSIONS_STORE_NAME, PUBKY_SESSIONS_DELEGATED_KEYS_STORE_NAME], "readwrite");
+      tx.objectStore(PUBKY_SESSIONS_STORE_NAME).delete(lease.id);
+      if (record.storageMode === "delegated") {
+        const { keyId } = JSON.parse(record.credential);
+        tx.objectStore(PUBKY_SESSIONS_DELEGATED_KEYS_STORE_NAME).delete(keyId);
+      }
+      tx.oncomplete = resolve;
+      tx.onerror = tx.onabort = () => reject(tx.error ?? new Error("Removing browser session failed."));
     });
-  } finally {
-    db.close();
-  }
+  } finally { db.close(); }
+  sessionChanged(lease.id, "removed");
+}
+async function __pubkySessionStoreClear() {
+  await navigator.locks.request(SESSION_STORE_LOCK, () => clearSessionStore());
+  sessionChanged(null, "cleared");
+}
+async function __pubkySessionStoreClearAll() {
+  await navigator.locks.request(SESSION_STORE_LOCK, () => clearSessionStore(true));
+  sessionChanged(null, "cleared");
 }
 
 const PUBKY_GRANT_KEYS_DB_NAME = "pubky-auth";
@@ -445,22 +533,40 @@ async function __pubkyGrantLoadDelegatedPublicKey(keyId) {
  * bytes are returned to Rust, which finishes compact JWS serialization.
  */
 async function __pubkyGrantDelegatedSign(keyId, signingInput) {
-  requireBrowserCrypto();
-  const existing = await getRecord(keyId);
-  if (!existing?.privateKey) throw new Error(`Delegated grant key not found: ${keyId}`);
+  let existing;
+  try {
+    requireBrowserCrypto();
+    existing = await getRecord(keyId);
+    if (!existing?.privateKey) throw new Error(`Delegated grant key not found: ${keyId}`);
+  } catch (cause) {
+    // getRecord wraps IndexedDB failures; retain the underlying diagnostic.
+    const detail = cause?.cause ?? cause;
+    const error = contextualError(
+      `Delegated grant signing key unavailable: ${detail?.message ?? String(detail)}`,
+      cause,
+    );
+    error.code = "SigningKeyUnavailable";
+    throw error;
+  }
   const data = new TextEncoder().encode(signingInput);
   return new Uint8Array(await crypto.subtle.sign({ name: "Ed25519" }, existing.privateKey, data));
 }
 
-/**
- * Delete a browser-held delegated grant key by id.
- *
- * Used when a persisted delegated session record is removed from the SDK
- * session store. Missing keys are treated as already deleted.
- */
-async function __pubkyGrantDeleteDelegatedKey(keyId) {
-  requireBrowserCrypto();
-  await deleteRecord(keyId);
+
+function __pubkyRecoveredEncryptionKeys(publicKey, grantId, keys) {
+    return { publicKey, grantId, keys };
+}
+
+async function __pubkyImportEncryptionCryptoKey(bytes) {
+    try {
+        if (!globalThis.crypto?.subtle) {
+            throw new Error("WebCrypto is unavailable; use a secure context.");
+        }
+        return await globalThis.crypto.subtle.importKey(
+            "raw", bytes, "AES-GCM", false, ["encrypt", "decrypt"]);
+    } finally {
+        bytes.fill(0);
+    }
 }
 
 /**
@@ -873,7 +979,7 @@ class BrowserSessionStore {
      * This removes all stored session records and all browser-held delegated
      * grant keys, including keys for pending delegated grant flows. Saved
      * delegated flow state becomes unrestorable. This does not revoke remote
-     * grants or immediately invalidate already-live in-memory sessions.
+     * grants. Browser-managed handles stop working when their saved record is removed.
      * @returns {Promise<void>}
      */
     clearAll() {
@@ -892,7 +998,7 @@ class BrowserSessionStore {
         return ret;
     }
     /**
-     * Whether IndexedDB is available for durable session persistence.
+     * Whether IndexedDB and Web Locks are available.
      * @returns {Promise<boolean>}
      */
     isAvailable() {
@@ -918,8 +1024,28 @@ class BrowserSessionStore {
         const ret = wasm.browsersessionstore_remove(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * Recover a stored session's encryption keys without network access.
+     * Verifies the signed approval, exact grant binding, and requested session
+     * identity. Works after grant expiry/revocation and without the delegated
+     * WebCrypto signing key.
+     * Restore material is stored as plaintext in IndexedDB.
+     * Bare-grant records return undefined; signed approvals without `e` scopes
+     * return an empty bundle. Creates no session.
+     * @param {string} id
+     * @returns {Promise<EncryptionKeys | undefined>}
+     */
+    restoreEncryptionKeys(id) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.browsersessionstore_restoreEncryptionKeys(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * Restore a specific stored session by id.
+     *
+     * Shares one bearer with other tabs on this origin. Requires IndexedDB and
+     * Web Locks in a secure browser context.
      * @param {string} id
      * @returns {Promise<Session>}
      */
@@ -930,7 +1056,11 @@ class BrowserSessionStore {
         return ret;
     }
     /**
-     * Persist a completed grant session in IndexedDB.
+     * Persist a completed grant session and its optional signed approval.
+     * Confidential restore material is stored as plaintext in IndexedDB.
+     * Delegated signing keys remain non-extractable WebCrypto keys.
+     * Records are identified by user and grant ID. Reauthorizing the same
+     * client creates a separate record; use the returned ID to restore it.
      * @param {Session} session
      * @returns {Promise<StoredSessionInfo>}
      */
@@ -1205,6 +1335,90 @@ class DirectSignupDeepLink {
 if (Symbol.dispose) DirectSignupDeepLink.prototype[Symbol.dispose] = DirectSignupDeepLink.prototype.free;
 exports.DirectSignupDeepLink = DirectSignupDeepLink;
 
+/**
+ * Verified scoped encryption keys obtained from a session or offline recovery.
+ * This object owns its secrets independently of the session and grants no storage
+ * access. Call `free()` when finished; secret bytes are zeroized on free/drop.
+ */
+class EncryptionKeys {
+    static __wrap(ptr) {
+        const obj = Object.create(EncryptionKeys.prototype);
+        obj.__wbg_ptr = ptr;
+        EncryptionKeysFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EncryptionKeysFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_encryptionkeys_free(ptr, 0);
+    }
+    /**
+     * Derive a non-extractable AES-GCM-256 key for WebCrypto encryption/decryption.
+     * Rejects directories and files outside approved scopes. Requires WebCrypto.
+     * Temporary JS key bytes are cleared after import, including on failure.
+     * @param {string} path
+     * @returns {Promise<CryptoKey>}
+     */
+    deriveCryptoKeyForPath(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encryptionkeys_deriveCryptoKeyForPath(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Derive a 32-byte content key for a canonical decoded file path.
+     * Rejects directories and files outside the approved scopes. The caller
+     * owns the JS byte copy and should clear it after use.
+     * @param {string} path
+     * @returns {Uint8Array}
+     */
+    deriveForPath(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encryptionkeys_deriveForPath(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Recover authenticated identity and keys from an exportLocalSecret() token offline.
+     * Verifies the signed approval and grant binding even if the grant expired
+     * or was revoked. Bare-grant tokens return undefined; signed approvals
+     * without `e` scopes return a result with an empty key bundle.
+     * Check publicKey (z-base-32) against the expected account and grantId
+     * against the expected grant before using keys. Call keys.free() when done.
+     * @param {string} token
+     * @returns {RecoveredEncryptionKeys | undefined}
+     */
+    static fromLocalSecret(token) {
+        const ptr0 = passStringToWasm0(token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encryptionkeys_fromLocalSecret(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Approved scopes; directory scopes cover descendant files.
+     * @returns {string[]}
+     */
+    get scopes() {
+        const ret = wasm.encryptionkeys_scopes(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) EncryptionKeys.prototype[Symbol.dispose] = EncryptionKeys.prototype.free;
+exports.EncryptionKeys = EncryptionKeys;
+
 /**
  * A single event from the event stream.
  *
@@ -1626,7 +1840,8 @@ class GrantAuthFlow {
      * Resume a previously saved pending grant auth flow (standalone).
      * Prefer `pubky.resumeGrantAuthFlow()` to reuse a facade client.
      *
-     * **Security:** `savedState` contains the relay secret and PoP client private key.
+     * **Security:** `savedState` contains the PoP client private key and either
+     * a shared relay secret or a temporary HPKE recipient secret.
      * Store it only temporarily and delete it once the flow completes or is abandoned.
      *
      * @param {string} savedState A string produced by `grantFlow.saveLocal()`.
@@ -1646,9 +1861,9 @@ class GrantAuthFlow {
     /**
      * Save sensitive state required to resume this delegated pending grant flow.
      *
-     * This does not export the delegated private key, but it includes the relay
-     * secret in the authorization URL. Store it only temporarily and delete it
-     * once the flow completes or is abandoned.
+     * This includes either a shared relay secret or a temporary HPKE recipient
+     * secret. Store it only temporarily and delete it once the flow completes
+     * or is abandoned.
      * @returns {string}
      */
     saveDelegated() {
@@ -1936,11 +2151,40 @@ class GrantSession {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_grantsession_free(ptr, 0);
     }
+    /**
+     * Sign JSON data and return both the custom proof and its root-signed grant.
+     * Data follows `JSON.stringify` semantics, e.g. `undefined` properties are omitted.
+     * Each proof carries its signing time (`iat`) and a random `nonce`.
+     * Makes no network requests. Your applications handle freshness and replay protection.
+     * @param {JsonValue} data
+     * @returns {Promise<CustomPop>}
+     */
+    createCustomPop(data) {
+        const ret = wasm.grantsession_createCustomPop(this.__wbg_ptr, data);
+        return ret;
+    }
+    /**
+     * Return scoped keys with the same derivation API as offline recovered keys.
+     * Bare grants return `undefined`; signed approvals without `e` scopes
+     * return an object with empty scopes.
+     * Each access creates an owned copy. Keep it for repeated use and call
+     * `free()` when finished. It remains usable after this view or its session
+     * is freed, signed out, or revoked; freeing it does not affect the session.
+     * @returns {EncryptionKeys | undefined}
+     */
+    get encryptionKeys() {
+        const ret = wasm.grantsession_encryptionKeys(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : EncryptionKeys.__wrap(ret[0]);
+    }
     /**
      * Export the portable local secret material needed to restore this grant session.
      *
      * Treat the returned string as bearer-equivalent secret material until the
-     * grant expires or is revoked.
+     * grant expires or is revoked. Included scoped keys remain sensitive after
+     * expiry or revocation.
      *
      * @returns {Promise<string>}
      * @returns {Promise<string>}
@@ -2777,8 +3021,9 @@ class Pubky {
     /**
      * Resume a previously saved pending grant auth flow.
      *
-     * **Security:** `savedState` contains the relay secret and PoP client private key.
-     * Delete it from storage as soon as the resumed flow completes.
+     * **Security:** `savedState` contains the PoP client private key and either
+     * a shared relay secret or a temporary HPKE private key. Delete it from
+     * storage when the flow completes or is abandoned.
      *
      * @param {string} savedState A string produced by `grantFlow.saveLocal()`.
      * @returns {GrantAuthFlow} A flow reconnected to the original relay channel.
@@ -2870,11 +3115,13 @@ class Pubky {
      *
      * Grant auth uses a user-signed grant JWS plus Proof-of-Possession and
      * returns a self-refreshing session.
+     * Select `approvalFormat: "signedApprovalV1"` and include `e` on scopes that need content
+     * keys. Storage `r` and `w` alone do not deliver encryption keys.
      *
      * @param {string} capabilities Comma-separated caps, e.g. `"/pub/app/:rw,/pub/foo/file:r"`.
      * @param {AuthFlowKind} kind The kind of authentication flow to perform.
      * @param {GrantAuthFlowOptions} options Options for the grant flow:
-     * `{ clientId, relay?, xCallback? }`.
+     * `{ clientId, relay?, xCallback?, approvalFormat? }`.
      * @returns {Promise<GrantAuthFlow>}
      * A running grant auth flow. Show `authorizationUrl` as QR/deeplink,
      * then `awaitApproval()` to obtain a grant-backed `Session`.
@@ -3560,7 +3807,8 @@ exports.SessionInfo = SessionInfo;
  * Only {@link SessionStorage.exists} and {@link SessionStorage.stats} treat
  * HTTP 404/410 as missing. Other HTTP failures, including 401/403 and 5xx, reject.
  * Writes require write permission and can fail on directory targets (400),
- * file/directory path conflicts (409), or exceeded quotas (507).
+ * file/directory path conflicts (409), a path someone holds a
+ * {@link StorageLock} on (423), or exceeded quotas (507).
  */
 class SessionStorage {
     static __wrap(ptr) {
@@ -3579,6 +3827,22 @@ class SessionStorage {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_sessionstorage_free(ptr, 0);
     }
+    /**
+     * `DELETE` the path of a lock this client holds. The lock stays in place.
+     *
+     * @param {StorageLock} lock A lock this client holds.
+     * @returns {Promise<void>}
+     * @throws {PubkyError} A lock that has expired or was unlocked rejects with
+     * `RequestError` and status `412`; take a new one.
+     * Otherwise as {@link SessionStorage.delete}.
+     * @param {StorageLock} lock
+     * @returns {Promise<void>}
+     */
+    deleteLocked(lock) {
+        _assertClass(lock, StorageLock);
+        const ret = wasm.sessionstorage_deleteLocked(this.__wbg_ptr, lock.__wbg_ptr);
+        return ret;
+    }
     /**
      * Delete a file. Directory targets are unsupported.
      *
@@ -3700,6 +3964,52 @@ class SessionStorage {
         const ret = wasm.sessionstorage_list(this.__wbg_ptr, ptr0, len0, ptr1, len1, isLikeNone(reverse) ? 0xFFFFFF : reverse ? 1 : 0, isLikeNone(limit) ? 0xFFFFFF : limit, isLikeNone(shallow) ? 0xFFFFFF : shallow ? 1 : 0);
         return ret;
     }
+    /**
+     * Take an exclusive write lock on a file at an **absolute session path**.
+     *
+     * The file need not exist; locking a free path reserves it. `timeoutSeconds` is
+     * the lifetime asked for; the homeserver caps it, and
+     * {@link StorageLock.timeoutSeconds} tells what was granted. A write made under
+     * the lock keeps it alive until the write ends, so it need not cover the upload itself.
+     *
+     * @param {Path} path File path; must not end with `/`.
+     * @param {number} timeoutSeconds Lifetime to ask for, in seconds; rounded down to
+     * whole seconds, and at least 1.
+     * @returns {Promise<StorageLock>} The granted lock.
+     * @throws {PubkyError} `InvalidInput` for a negative, NaN or out-of-range timeout;
+     * a path that is already locked rejects with `RequestError` and status `423`;
+     * directory targets with `400`; a homeserver without lock support with `405`.
+     * See {@link SessionStorage} for shared errors.
+     * @param {Path} path
+     * @param {number} timeout_seconds
+     * @returns {Promise<StorageLock>}
+     */
+    lock(path, timeout_seconds) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sessionstorage_lock(this.__wbg_ptr, ptr0, len0, timeout_seconds);
+        return ret;
+    }
+    /**
+     * `PUT` binary data to the path of a lock this client holds.
+     *
+     * @param {StorageLock} lock A lock this client holds.
+     * @param {Uint8Array} body
+     * @returns {Promise<void>}
+     * @throws {PubkyError} A lock that has expired or was unlocked rejects with
+     * `RequestError` and status `412`; take a new one and read the file again.
+     * Otherwise as {@link SessionStorage.putBytes}.
+     * @param {StorageLock} lock
+     * @param {Uint8Array} body
+     * @returns {Promise<void>}
+     */
+    putBytesLocked(lock, body) {
+        _assertClass(lock, StorageLock);
+        const ptr0 = passArray8ToWasm0(body, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sessionstorage_putBytesLocked(this.__wbg_ptr, lock.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * Create or replace a file with binary data at an absolute session path.
      *
@@ -3737,6 +4047,26 @@ class SessionStorage {
         const ret = wasm.sessionstorage_putJson(this.__wbg_ptr, ptr0, len0, body);
         return ret;
     }
+    /**
+     * `PUT` text to the path of a lock this client holds.
+     *
+     * @param {StorageLock} lock A lock this client holds.
+     * @param {string} body
+     * @returns {Promise<void>}
+     * @throws {PubkyError} A lock that has expired or was unlocked rejects with
+     * `RequestError` and status `412`; take a new one and read the file again.
+     * Otherwise as {@link SessionStorage.putText}.
+     * @param {StorageLock} lock
+     * @param {string} body
+     * @returns {Promise<void>}
+     */
+    putTextLocked(lock, body) {
+        _assertClass(lock, StorageLock);
+        const ptr0 = passStringToWasm0(body, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sessionstorage_putTextLocked(this.__wbg_ptr, lock.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * Create or replace a file with text at an absolute session path.
      *
@@ -3756,6 +4086,29 @@ class SessionStorage {
         const ret = wasm.sessionstorage_putText(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
+    /**
+     * Restart the lifetime of a lock this client holds.
+     *
+     * On success the lock carries the newly granted
+     * {@link StorageLock.timeoutSeconds}.
+     *
+     * @param {StorageLock} lock A lock this client holds.
+     * @param {number} timeoutSeconds Lifetime to ask for, in seconds; rounded down to
+     * whole seconds, and at least 1.
+     * @returns {Promise<void>}
+     * @throws {PubkyError} A lock that has expired or was unlocked rejects with
+     * `RequestError` and status `412`; take a new one and read the file again.
+     * `InvalidInput` for a negative, NaN or out-of-range timeout.
+     * See {@link SessionStorage} for shared errors.
+     * @param {StorageLock} lock
+     * @param {number} timeout_seconds
+     * @returns {Promise<void>}
+     */
+    refreshLock(lock, timeout_seconds) {
+        _assertClass(lock, StorageLock);
+        const ret = wasm.sessionstorage_refreshLock(this.__wbg_ptr, lock.__wbg_ptr, timeout_seconds);
+        return ret;
+    }
     /**
      * Get metadata for an absolute, session-scoped path (e.g. `"/pub/app/file.json"`).
      *
@@ -3773,6 +4126,21 @@ class SessionStorage {
         const ret = wasm.sessionstorage_stats(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * Release a lock this client holds.
+     *
+     * @param {StorageLock} lock A lock this client holds.
+     * @returns {Promise<void>}
+     * @throws {PubkyError} A lock that no longer exists rejects with `RequestError`
+     * and status `409`. See {@link SessionStorage} for shared errors.
+     * @param {StorageLock} lock
+     * @returns {Promise<void>}
+     */
+    unlock(lock) {
+        _assertClass(lock, StorageLock);
+        const ret = wasm.sessionstorage_unlock(this.__wbg_ptr, lock.__wbg_ptr);
+        return ret;
+    }
 }
 if (Symbol.dispose) SessionStorage.prototype[Symbol.dispose] = SessionStorage.prototype.free;
 exports.SessionStorage = SessionStorage;
@@ -3868,7 +4236,8 @@ class Signer {
     /**
      * Blocking sign-in. Waits for PKDNS publish to complete (slower; safer).
      *
-     * Creates a valid grant-backed homeserver Session with root capabilities.
+     * Creates a grant-backed homeserver session with root storage access (`/:rw`).
+     * Encryption keys require an explicit `e` request through a signed approval flow.
      * `clientId` is shown in the user's grant/session list.
      * @param {string} clientId App identifier, typically a domain.
      *
@@ -3905,7 +4274,8 @@ class Signer {
     /**
      * Fast sign-in for a returning user. Publishes PKDNS in the background.
      *
-     * Creates a valid grant-backed homeserver Session with root capabilities.
+     * Creates a grant-backed homeserver session with root storage access (`/:rw`).
+     * Encryption keys require an explicit `e` request through a signed approval flow.
      * `clientId` is shown in the user's grant/session list.
      * @param {string} clientId App identifier, typically a domain.
      *
@@ -4083,6 +4453,22 @@ class SigninGrantDeepLink {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_signingrantdeeplink_free(ptr, 0);
     }
+    /**
+     * Negotiated approval format: `bareGrant` or `signedApprovalV1`.
+     * @returns {string}
+     */
+    get approvalFormat() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signingrantdeeplink_approvalFormat(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Base HTTP relay inbox URL used by this auth request.
      *
@@ -4147,6 +4533,19 @@ class SigninGrantDeepLink {
         const ret = wasm.signingrantdeeplink_clientPublicKey(this.__wbg_ptr);
         return PublicKey.__wrap(ret);
     }
+    /**
+     * The 32-byte ephemeral HPKE public key from `epk`, or `undefined`
+     * for a shared-secret link. The relay channel ID is the unpadded
+     * base64url encoding of BLAKE3("pubky-grant-relay-channel-v1" || 0x00 || epk),
+     * where `||` concatenates bytes and `epk` is the raw 32-byte public key.
+     *
+     * @returns {Uint8Array|undefined}
+     * @returns {Uint8Array | undefined}
+     */
+    get ephemeralPublicKey() {
+        const ret = wasm.signingrantdeeplink_ephemeralPublicKey(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Parse a grant signin deeplink URL.
      *
@@ -4166,12 +4565,11 @@ class SigninGrantDeepLink {
         return SigninGrantDeepLink.__wrap(ret[0]);
     }
     /**
-     * Relay channel secret embedded in the deeplink.
-     *
-     * Treat this as sensitive temporary auth-flow material.
+     * Shared relay secret, or `undefined` for an HPKE link.
+     * Keep this secret confidential until the flow completes or is abandoned.
      *
-     * @returns {Uint8Array}
-     * @returns {Uint8Array}
+     * @returns {Uint8Array|undefined}
+     * @returns {Uint8Array | undefined}
      */
     get secret() {
         const ret = wasm.signingrantdeeplink_secret(this.__wbg_ptr);
@@ -4349,6 +4747,22 @@ class SignupGrantDeepLink {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_signupgrantdeeplink_free(ptr, 0);
     }
+    /**
+     * Negotiated approval format: `bareGrant` or `signedApprovalV1`.
+     * @returns {string}
+     */
+    get approvalFormat() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signupgrantdeeplink_approvalFormat(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Base HTTP relay inbox URL used by this auth request.
      *
@@ -4413,6 +4827,19 @@ class SignupGrantDeepLink {
         const ret = wasm.signupgrantdeeplink_clientPublicKey(this.__wbg_ptr);
         return PublicKey.__wrap(ret);
     }
+    /**
+     * The 32-byte ephemeral HPKE public key from `epk`, or `undefined`
+     * for a shared-secret link. The relay channel ID is the unpadded
+     * base64url encoding of BLAKE3("pubky-grant-relay-channel-v1" || 0x00 || epk),
+     * where `||` concatenates bytes and `epk` is the raw 32-byte public key.
+     *
+     * @returns {Uint8Array|undefined}
+     * @returns {Uint8Array | undefined}
+     */
+    get ephemeralPublicKey() {
+        const ret = wasm.signupgrantdeeplink_ephemeralPublicKey(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Homeserver public key requested for account creation.
      *
@@ -4442,12 +4869,11 @@ class SignupGrantDeepLink {
         return SignupGrantDeepLink.__wrap(ret[0]);
     }
     /**
-     * Relay channel secret embedded in the deeplink.
-     *
-     * Treat this as sensitive temporary auth-flow material.
+     * Shared relay secret, or `undefined` for an HPKE link.
+     * Keep this secret confidential until the flow completes or is abandoned.
      *
-     * @returns {Uint8Array}
-     * @returns {Uint8Array}
+     * @returns {Uint8Array|undefined}
+     * @returns {Uint8Array | undefined}
      */
     get secret() {
         const ret = wasm.signupgrantdeeplink_secret(this.__wbg_ptr);
@@ -4501,6 +4927,107 @@ class SignupGrantDeepLink {
 if (Symbol.dispose) SignupGrantDeepLink.prototype[Symbol.dispose] = SignupGrantDeepLink.prototype.free;
 exports.SignupGrantDeepLink = SignupGrantDeepLink;
 
+/**
+ * An exclusive write lock on one file path, granted by the homeserver.
+ *
+ * While the lock lives, only writes that present it are accepted on the path;
+ * every other write, and every other {@link SessionStorage.lock}, rejects with
+ * `423 Locked`. The lock ends when it is {@link SessionStorage.unlock | unlocked}
+ * or when its {@link StorageLock.timeoutSeconds} runs out without a
+ * {@link SessionStorage.refreshLock | refresh}, so a client that disappears never
+ * blocks a path for long.
+ *
+ * The lock is a bearer token: whoever holds this value, and may write the path,
+ * can use and release the lock.
+ *
+ * Calls that take the lock may overlap: a {@link SessionStorage.refreshLock | refresh}
+ * can run while a locked write is in flight.
+ *
+ * @example
+ * const lock = await session.storage.lock("/pub/my.app/state.json", 30);
+ * const state = await session.storage.getText(lock.path);
+ * await session.storage.putTextLocked(lock, state);
+ * await session.storage.unlock(lock);
+ */
+class StorageLock {
+    static __wrap(ptr) {
+        const obj = Object.create(StorageLock.prototype);
+        obj.__wbg_ptr = ptr;
+        StorageLockFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StorageLockFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_storagelock_free(ptr, 0);
+    }
+    /**
+     * Value of the `If` header that presents this lock on a write.
+     * @returns {string}
+     */
+    ifHeader() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.storagelock_ifHeader(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The locked path.
+     * @returns {Path}
+     */
+    get path() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.storagelock_path(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Lifetime the homeserver granted at the last `lock` or `refreshLock`, in seconds,
+     * counted from when that call resolved. It may be shorter than what was asked for.
+     * It is not the time remaining: note when the call resolved to know when to refresh.
+     * @returns {number}
+     */
+    get timeoutSeconds() {
+        const ret = wasm.storagelock_timeoutSeconds(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The lock token URL, `opaquelocktoken:<uuid>`.
+     * @returns {string}
+     */
+    get token() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.storagelock_token(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) StorageLock.prototype[Symbol.dispose] = StorageLock.prototype.free;
+exports.StorageLock = StorageLock;
+
 /**
  * Metadata for a session saved in the browser session store.
  */
@@ -4710,7 +5237,8 @@ exports.setLogLevel = setLogLevel;
 /**
  * Validate and normalize a capabilities string.
  *
- * - Normalizes action order (`wr` -> `rw`)
+ * - Normalizes action order (`wr` -> `rw`, `ewr` -> `rwe`).
+ * - `e` requests scoped encryption/decryption keys in V1 grant approvals.
  * - Throws `InvalidInput` identifying the first malformed entry.
  *
  * @param {string} input
@@ -4741,58 +5269,93 @@ function validateCapabilities(input) {
     }
 }
 exports.validateCapabilities = validateCapabilities;
+
+/**
+ * Verify both signatures, grant binding, and grant validity against the local clock.
+ * Allows 30 seconds of future clock skew by default; never extends grant expiry.
+ * Does not check replay, application authorization, or homeserver revocation.
+ * @param {CustomPop} credentials
+ * @param {CustomPopVerificationOptions | null} [options]
+ * @returns {VerifiedCustomPop}
+ */
+function verifyCustomGrantPop(credentials, options) {
+    const ret = wasm.verifyCustomGrantPop(credentials, isLikeNone(options) ? 0 : addToExternrefTable0(options));
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.verifyCustomGrantPop = verifyCustomGrantPop;
 const import1 = {
-  __pubkyGrantIsDelegationAvailable,
-  __pubkyGrantCanUseDelegation,
-  __pubkyGrantEnsureDelegatedKey,
-  __pubkyGrantLoadDelegatedPublicKey,
-  __pubkyGrantDelegatedSign,
-  __pubkyGrantDeleteDelegatedKey,
-};
-const import2 = {
   __pubkySessionStoreIsAvailable,
   __pubkySessionStorePut,
+  __pubkySessionStoreMetadata,
   __pubkySessionStoreGet,
   __pubkySessionStoreList,
-  __pubkySessionStoreDelete,
+  __pubkySessionAcquire,
+  __pubkySessionWait,
+  __pubkySessionRelease,
+  __pubkySharedSessionLoad,
+  __pubkySharedSessionStore,
+  __pubkySharedSessionRemove,
   __pubkySessionStoreClear,
   __pubkySessionStoreClearAll,
 };
-const import3 = {
+const import2 = {
   __pubkySessionStoreIsAvailable,
   __pubkySessionStorePut,
+  __pubkySessionStoreMetadata,
   __pubkySessionStoreGet,
   __pubkySessionStoreList,
-  __pubkySessionStoreDelete,
+  __pubkySessionAcquire,
+  __pubkySessionWait,
+  __pubkySessionRelease,
+  __pubkySharedSessionLoad,
+  __pubkySharedSessionStore,
+  __pubkySharedSessionRemove,
   __pubkySessionStoreClear,
   __pubkySessionStoreClearAll,
 };
-const import4 = {
+const import3 = {
   __pubkySessionStoreIsAvailable,
   __pubkySessionStorePut,
+  __pubkySessionStoreMetadata,
   __pubkySessionStoreGet,
   __pubkySessionStoreList,
-  __pubkySessionStoreDelete,
+  __pubkySessionAcquire,
+  __pubkySessionWait,
+  __pubkySessionRelease,
+  __pubkySharedSessionLoad,
+  __pubkySharedSessionStore,
+  __pubkySharedSessionRemove,
   __pubkySessionStoreClear,
   __pubkySessionStoreClearAll,
 };
-const import5 = {
+const import4 = {
   __pubkySessionStoreIsAvailable,
   __pubkySessionStorePut,
+  __pubkySessionStoreMetadata,
   __pubkySessionStoreGet,
   __pubkySessionStoreList,
-  __pubkySessionStoreDelete,
+  __pubkySessionAcquire,
+  __pubkySessionWait,
+  __pubkySessionRelease,
+  __pubkySharedSessionLoad,
+  __pubkySharedSessionStore,
+  __pubkySharedSessionRemove,
   __pubkySessionStoreClear,
   __pubkySessionStoreClearAll,
 };
+const import5 = {
+  __pubkyGrantIsDelegationAvailable,
+  __pubkyGrantCanUseDelegation,
+  __pubkyGrantEnsureDelegatedKey,
+  __pubkyGrantLoadDelegatedPublicKey,
+  __pubkyGrantDelegatedSign,
+};
 const import6 = {
-  __pubkySessionStoreIsAvailable,
-  __pubkySessionStorePut,
-  __pubkySessionStoreGet,
-  __pubkySessionStoreList,
-  __pubkySessionStoreDelete,
-  __pubkySessionStoreClear,
-  __pubkySessionStoreClearAll,
+  __pubkyRecoveredEncryptionKeys,
+  __pubkyImportEncryptionCryptoKey,
 };
 const import7 = {
   __pubkyGrantIsDelegationAvailable,
@@ -4800,7 +5363,6 @@ const import7 = {
   __pubkyGrantEnsureDelegatedKey,
   __pubkyGrantLoadDelegatedPublicKey,
   __pubkyGrantDelegatedSign,
-  __pubkyGrantDeleteDelegatedKey,
 };
 
 function __wbg_get_imports() {
@@ -4821,7 +5383,7 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___pubkyGrantDelegatedSign_75d50e1487a4c01e: function(arg0, arg1, arg2, arg3) {
+        __wbg___pubkyGrantDelegatedSign_45b22729433b1c79: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -4838,19 +5400,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg___pubkyGrantDeleteDelegatedKey_8c61ee224046056d: function(arg0, arg1) {
-            let deferred0_0;
-            let deferred0_1;
-            try {
-                deferred0_0 = arg0;
-                deferred0_1 = arg1;
-                const ret = __pubkyGrantDeleteDelegatedKey(getStringFromWasm0(arg0, arg1));
-                return ret;
-            } finally {
-                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-            }
-        },
-        __wbg___pubkyGrantEnsureDelegatedKey_70e2f9e5fbabf7e4: function(arg0, arg1) {
+        __wbg___pubkyGrantEnsureDelegatedKey_4f1cc4ccb5acf4e8: function(arg0, arg1) {
             let v0;
             if (arg0 !== 0) {
                 v0 = getStringFromWasm0(arg0, arg1);
@@ -4859,7 +5409,7 @@ function __wbg_get_imports() {
             const ret = __pubkyGrantEnsureDelegatedKey(v0);
             return ret;
         },
-        __wbg___pubkyGrantLoadDelegatedPublicKey_5fed290b4e324487: function(arg0, arg1) {
+        __wbg___pubkyGrantLoadDelegatedPublicKey_6591f0667321395a: function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -4871,30 +5421,61 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg___pubkySessionStoreDelete_c4feadf1aabc11f4: function(arg0, arg1) {
+        __wbg___pubkyRecoveredEncryptionKeys_7375e79d20b5b126: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = __pubkyRecoveredEncryptionKeys(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), EncryptionKeys.__wrap(arg4));
+            return ret;
+        },
+        __wbg___pubkySessionAcquire_356f865b2001b846: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = __pubkySessionAcquire(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), arg4 !== 0);
+            return ret;
+        }, arguments); },
+        __wbg___pubkySessionRelease_3195014f66dee6ac: function(arg0) {
+            __pubkySessionRelease(arg0 >>> 0);
+        },
+        __wbg___pubkySessionStoreGet_618e59d7f6ad6c2a: function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
             try {
                 deferred0_0 = arg0;
                 deferred0_1 = arg1;
-                const ret = __pubkySessionStoreDelete(getStringFromWasm0(arg0, arg1));
+                const ret = __pubkySessionStoreGet(getStringFromWasm0(arg0, arg1));
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg___pubkySessionStoreGet_faa5b9fdbff7a8b0: function(arg0, arg1) {
+        __wbg___pubkySessionStoreMetadata_a69b8b6778109b6e: function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
             try {
                 deferred0_0 = arg0;
                 deferred0_1 = arg1;
-                const ret = __pubkySessionStoreGet(getStringFromWasm0(arg0, arg1));
+                const ret = __pubkySessionStoreMetadata(getStringFromWasm0(arg0, arg1));
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
+        __wbg___pubkySessionStorePut_aa2189e6e7fdc513: function(arg0, arg1) {
+            const ret = __pubkySessionStorePut(arg0, arg1 >>> 0);
+            return ret;
+        },
+        __wbg___pubkySessionWait_a67a8077a61d91d1: function(arg0) {
+            const ret = __pubkySessionWait(arg0 >>> 0);
+            return ret;
+        },
+        __wbg___pubkySharedSessionLoad_4190e716399b75e0: function(arg0) {
+            const ret = __pubkySharedSessionLoad(arg0 >>> 0);
+            return ret;
+        },
+        __wbg___pubkySharedSessionRemove_f037c015c530dc4d: function(arg0) {
+            const ret = __pubkySharedSessionRemove(arg0 >>> 0);
+            return ret;
+        },
+        __wbg___pubkySharedSessionStore_3e370536d89738a5: function(arg0, arg1) {
+            const ret = __pubkySharedSessionStore(arg0 >>> 0, arg1);
+            return ret;
+        },
         __wbg___wbindgen_bigint_get_as_i64_b482365c149396c8: function(arg0, arg1) {
             const v = arg1;
             const ret = typeof(v) === 'bigint' ? v : undefined;
@@ -5044,6 +5625,10 @@ function __wbg_get_imports() {
             const ret = arg0.done;
             return ret;
         },
+        __wbg_encryptionkeys_new: function(arg0) {
+            const ret = EncryptionKeys.__wrap(arg0);
+            return ret;
+        },
         __wbg_enqueue_6cb545d22db14f33: function() { return handleError(function (arg0, arg1) {
             arg0.enqueue(arg1);
         }, arguments); },
@@ -5066,12 +5651,12 @@ function __wbg_get_imports() {
             const ret = fetch(arg0);
             return ret;
         },
-        __wbg_fetch_920242d59bac2026: function(arg0, arg1) {
-            const ret = arg0.fetch(arg1);
+        __wbg_fetch_8ce5bc1de67f3146: function(arg0) {
+            const ret = fetch(arg0);
             return ret;
         },
-        __wbg_fetch_bed2d90618c78f90: function(arg0) {
-            const ret = fetch(arg0);
+        __wbg_fetch_920242d59bac2026: function(arg0, arg1) {
+            const ret = arg0.fetch(arg1);
             return ret;
         },
         __wbg_from_a39669ce566077da: function(arg0) {
@@ -5149,6 +5734,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_CryptoKey_98e09fab6f03bfea: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof CryptoKey;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Error_fe6fa771c78ee4cf: function(arg0) {
             let result;
             try {
@@ -5222,6 +5817,10 @@ function __wbg_get_imports() {
         __wbg_log_d4082f66a52944c3: function(arg0, arg1, arg2, arg3) {
             console.log(arg0, arg1, arg2, arg3);
         },
+        __wbg_message_1cbc5bc03dcf1dee: function(arg0) {
+            const ret = arg0.message;
+            return ret;
+        },
         __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
             const ret = arg0.msCrypto;
             return ret;
@@ -5265,7 +5864,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke___js_sys_9e06d9a37a23efa4___Function_fn_wasm_bindgen_ce198afa7cd4a644___JsValue_____wasm_bindgen_ce198afa7cd4a644___sys__Undefined___js_sys_9e06d9a37a23efa4___Function_fn_wasm_bindgen_ce198afa7cd4a644___JsValue_____wasm_bindgen_ce198afa7cd4a644___sys__Undefined_______true_(a, state0.b, arg0, arg1);
+                        return wasm_bindgen_6fb33c0245079662___convert__closures_____invoke___js_sys_5fd4844d262c835b___Function_fn_wasm_bindgen_6fb33c0245079662___JsValue_____wasm_bindgen_6fb33c0245079662___sys__Undefined___js_sys_5fd4844d262c835b___Function_fn_wasm_bindgen_6fb33c0245079662___JsValue_____wasm_bindgen_6fb33c0245079662___sys__Undefined_______true_(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -5457,6 +6056,10 @@ function __wbg_get_imports() {
             const ret = arg0.status;
             return ret;
         },
+        __wbg_storagelock_new: function(arg0) {
+            const ret = StorageLock.__wrap(arg0);
+            return ret;
+        },
         __wbg_storedsessioninfo_new: function(arg0) {
             const ret = StoredSessionInfo.__wrap(arg0);
             return ret;
@@ -5508,18 +6111,18 @@ function __wbg_get_imports() {
             console.warn(arg0, arg1, arg2, arg3);
         },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 133, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke___wasm_bindgen_ce198afa7cd4a644___JsValue__core_ed718c3d60ebd546___result__Result_____wasm_bindgen_ce198afa7cd4a644___JsError___true_);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 125, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_6fb33c0245079662___convert__closures_____invoke___wasm_bindgen_6fb33c0245079662___JsValue__core_608f92abc48d28da___result__Result_____wasm_bindgen_6fb33c0245079662___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 275, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke___wasm_bindgen_ce198afa7cd4a644___JsValue______true_);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 284, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_6fb33c0245079662___convert__closures_____invoke___wasm_bindgen_6fb33c0245079662___JsValue______true_);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 273, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke_______true_);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 282, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_6fb33c0245079662___convert__closures_____invoke_______true_);
             return ret;
         },
         __wbindgen_generic_0000000000000004: function(arg0) {
@@ -5557,14 +6160,14 @@ function __wbg_get_imports() {
         __wbindgen_generic_000000000000000a: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1);
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
-            // Cast intrinsic for `Vector(RustStruct { name: "GrantInfo", unique_crate_identifier: "pubky-wasm-77c580e5b10ee397" }) -> Externref`.
+            // Cast intrinsic for `Vector(RustStruct { name: "GrantInfo", unique_crate_identifier: "pubky-wasm-a72b7beb1b0b81b7" }) -> Externref`.
             const ret = v0;
             return ret;
         },
         __wbindgen_generic_000000000000000b: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1);
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
-            // Cast intrinsic for `Vector(RustStruct { name: "StoredSessionInfo", unique_crate_identifier: "pubky-wasm-77c580e5b10ee397" }) -> Externref`.
+            // Cast intrinsic for `Vector(RustStruct { name: "StoredSessionInfo", unique_crate_identifier: "pubky-wasm-a72b7beb1b0b81b7" }) -> Externref`.
             const ret = v0;
             return ret;
         },
@@ -5581,33 +6184,33 @@ function __wbg_get_imports() {
     return {
         __proto__: null,
         "./pubky_bg.js": import0,
-        "./snippets/pubky-wasm-77c580e5b10ee397/inline1.js": import1,
-        "./snippets/pubky-wasm-77c580e5b10ee397/inline0.js": import2,
-        "./snippets/pubky-wasm-77c580e5b10ee397/inline0.js": import3,
-        "./snippets/pubky-wasm-77c580e5b10ee397/inline0.js": import4,
-        "./snippets/pubky-wasm-77c580e5b10ee397/inline0.js": import5,
-        "./snippets/pubky-wasm-77c580e5b10ee397/inline0.js": import6,
-        "./snippets/pubky-wasm-77c580e5b10ee397/inline1.js": import7,
+        "./snippets/pubky-wasm-a72b7beb1b0b81b7/inline0.js": import1,
+        "./snippets/pubky-wasm-a72b7beb1b0b81b7/inline0.js": import2,
+        "./snippets/pubky-wasm-a72b7beb1b0b81b7/inline0.js": import3,
+        "./snippets/pubky-wasm-a72b7beb1b0b81b7/inline0.js": import4,
+        "./snippets/pubky-wasm-a72b7beb1b0b81b7/inline1.js": import5,
+        "./snippets/pubky-wasm-a72b7beb1b0b81b7/inline2.js": import6,
+        "./snippets/pubky-wasm-a72b7beb1b0b81b7/inline1.js": import7,
     };
 }
 
-function wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke_______true_(arg0, arg1) {
-    wasm.wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke_______true_(arg0, arg1);
+function wasm_bindgen_6fb33c0245079662___convert__closures_____invoke_______true_(arg0, arg1) {
+    wasm.wasm_bindgen_6fb33c0245079662___convert__closures_____invoke_______true_(arg0, arg1);
 }
 
-function wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke___wasm_bindgen_ce198afa7cd4a644___JsValue______true_(arg0, arg1, arg2) {
-    wasm.wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke___wasm_bindgen_ce198afa7cd4a644___JsValue______true_(arg0, arg1, arg2);
+function wasm_bindgen_6fb33c0245079662___convert__closures_____invoke___wasm_bindgen_6fb33c0245079662___JsValue______true_(arg0, arg1, arg2) {
+    wasm.wasm_bindgen_6fb33c0245079662___convert__closures_____invoke___wasm_bindgen_6fb33c0245079662___JsValue______true_(arg0, arg1, arg2);
 }
 
-function wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke___wasm_bindgen_ce198afa7cd4a644___JsValue__core_ed718c3d60ebd546___result__Result_____wasm_bindgen_ce198afa7cd4a644___JsError___true_(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke___wasm_bindgen_ce198afa7cd4a644___JsValue__core_ed718c3d60ebd546___result__Result_____wasm_bindgen_ce198afa7cd4a644___JsError___true_(arg0, arg1, arg2);
+function wasm_bindgen_6fb33c0245079662___convert__closures_____invoke___wasm_bindgen_6fb33c0245079662___JsValue__core_608f92abc48d28da___result__Result_____wasm_bindgen_6fb33c0245079662___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_6fb33c0245079662___convert__closures_____invoke___wasm_bindgen_6fb33c0245079662___JsValue__core_608f92abc48d28da___result__Result_____wasm_bindgen_6fb33c0245079662___JsError___true_(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke___js_sys_9e06d9a37a23efa4___Function_fn_wasm_bindgen_ce198afa7cd4a644___JsValue_____wasm_bindgen_ce198afa7cd4a644___sys__Undefined___js_sys_9e06d9a37a23efa4___Function_fn_wasm_bindgen_ce198afa7cd4a644___JsValue_____wasm_bindgen_ce198afa7cd4a644___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen_ce198afa7cd4a644___convert__closures_____invoke___js_sys_9e06d9a37a23efa4___Function_fn_wasm_bindgen_ce198afa7cd4a644___JsValue_____wasm_bindgen_ce198afa7cd4a644___sys__Undefined___js_sys_9e06d9a37a23efa4___Function_fn_wasm_bindgen_ce198afa7cd4a644___JsValue_____wasm_bindgen_ce198afa7cd4a644___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
+function wasm_bindgen_6fb33c0245079662___convert__closures_____invoke___js_sys_5fd4844d262c835b___Function_fn_wasm_bindgen_6fb33c0245079662___JsValue_____wasm_bindgen_6fb33c0245079662___sys__Undefined___js_sys_5fd4844d262c835b___Function_fn_wasm_bindgen_6fb33c0245079662___JsValue_____wasm_bindgen_6fb33c0245079662___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_6fb33c0245079662___convert__closures_____invoke___js_sys_5fd4844d262c835b___Function_fn_wasm_bindgen_6fb33c0245079662___JsValue_____wasm_bindgen_6fb33c0245079662___sys__Undefined___js_sys_5fd4844d262c835b___Function_fn_wasm_bindgen_6fb33c0245079662___JsValue_____wasm_bindgen_6fb33c0245079662___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
 }
 
 
@@ -5648,6 +6251,9 @@ const CookieSessionFinalization = (typeof FinalizationRegistry === 'undefined')
 const DirectSignupDeepLinkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_directsignupdeeplink_free(ptr, 1));
+const EncryptionKeysFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encryptionkeys_free(ptr, 1));
 const EventFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_event_free(ptr, 1));
@@ -5732,6 +6338,9 @@ const SignupDeepLinkFinalization = (typeof FinalizationRegistry === 'undefined')
 const SignupGrantDeepLinkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_signupgrantdeeplink_free(ptr, 1));
+const StorageLockFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_storagelock_free(ptr, 1));
 const StoredSessionInfoFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_storedsessioninfo_free(ptr, 1));