@synonymdev/pubky 0.6.0-rc.2 → 0.6.0-rc.7

package/index.cjs

@@ -6,8 +6,6 @@ globalThis.fetch = makeFetchCookie(originalFetch);
 
 let imports = {};
 imports['__wbindgen_placeholder__'] = module.exports;
-let wasm;
-const { TextDecoder, TextEncoder } = require(`util`);
 
 let cachedUint8ArrayMemory0 = null;
 
@@ -33,20 +31,18 @@ function getStringFromWasm0(ptr, len) {
 
 let WASM_VECTOR_LEN = 0;
 
-const cachedTextEncoder = new TextEncoder('utf-8');
+const cachedTextEncoder = new TextEncoder();
 
-const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
-    ? function (arg, view) {
-    return cachedTextEncoder.encodeInto(arg, view);
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
 }
-    : function (arg, view) {
-    const buf = cachedTextEncoder.encode(arg);
-    view.set(buf);
-    return {
-        read: arg.length,
-        written: buf.length
-    };
-});
 
 function passStringToWasm0(arg, malloc, realloc) {
 
@@ -77,7 +73,7 @@ function passStringToWasm0(arg, malloc, realloc) {
         }
         ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
         const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = encodeString(arg, view);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
 
         offset += ret.written;
         ptr = realloc(ptr, len, offset, 1) >>> 0;
@@ -96,61 +92,10 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_export_4.set(idx, obj);
-    return idx;
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
-    }
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(state => {
-    wasm.__wbindgen_export_5.get(state.dtor)(state.a, state.b)
-});
-
-function makeMutClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        const a = state.a;
-        state.a = 0;
-        try {
-            return f(a, state.b, ...args);
-        } finally {
-            if (--state.cnt === 0) {
-                wasm.__wbindgen_export_5.get(state.dtor)(a, state.b);
-                CLOSURE_DTORS.unregister(state);
-            } else {
-                state.a = a;
-            }
-        }
-    };
-    real.original = state;
-    CLOSURE_DTORS.register(real, state, state);
-    return real;
-}
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -216,6 +161,69 @@ function debugString(val) {
     return className;
 }
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
@@ -223,7 +231,7 @@ function _assertClass(instance, klass) {
 }
 
 function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_4.get(idx);
+    const value = wasm.__wbindgen_externrefs.get(idx);
     wasm.__externref_table_dealloc(idx);
     return value;
 }
@@ -234,27 +242,16 @@ function passArray8ToWasm0(arg, malloc) {
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
-
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true)));
-    }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
-}
 /**
  * Set the global logging verbosity for the WASM Pubky SDK. Routes Rust `log` output to the browser console.
  *
- * Accepted values (case-insensitive): "error" | "warn" | "info" | "debug" | "trace".
+ * Accepted values (case-sensitive): "error" | "warn" | "info" | "debug" | "trace".
  * Effects:
  * - Initializes the logger once; subsequent calls may throw if the logger is already set.
  * - Emits a single info log: `Log level set to: <level>`.
  * - Messages at or above `level` are forwarded to the appropriate `console.*` method.
  *
- * @param {string} level
+ * @param {Level} level
  *        Minimum log level to enable. One of: "error" | "warn" | "info" | "debug" | "trace".
  *
  * @returns {void}
@@ -265,17 +262,44 @@ function getArrayJsValueFromWasm0(ptr, len) {
  *
  * Usage:
  *   Call once at application startup, before invoking other SDK APIs.
- * @param {string} level
+ * @param {Level} level
  */
-module.exports.setLogLevel = function(level) {
-    const ptr0 = passStringToWasm0(level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.setLogLevel(ptr0, len0);
+exports.setLogLevel = function(level) {
+    const ret = wasm.setLogLevel((__wbindgen_enum_Level.indexOf(level) + 1 || 6) - 1);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 };
 
+/**
+ * Resolve a `pubky://` or `pubky<pk>/…` identifier into the homeserver transport URL.
+ *
+ * @param {string} identifier Either `pubky<pk>/...` (preferred) or `pubky://<pk>/...`.
+ * @returns {string} HTTPS URL in the form `https://_pubky.<pk>/...`.
+ * @param {string} identifier
+ * @returns {string}
+ */
+exports.resolvePubky = function(identifier) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.resolvePubky(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+};
+
 /**
  * Validate and normalize a capabilities string.
  *
@@ -284,11 +308,12 @@ module.exports.setLogLevel = function(level) {
  *
  * @param {string} input
  * @returns {string} Normalized string (same shape as input).
- * @throws {PubkyJsError} `{ name: "InvalidInput" }` with a helpful message.
+ * @throws {PubkyError} `{ name: "InvalidInput" }` with a helpful message.
+ * The error's `data` field is `{ invalidEntries: string[] }` listing malformed tokens.
  * @param {string} input
  * @returns {string}
  */
-module.exports.validateCapabilities = function(input) {
+exports.validateCapabilities = function(input) {
     let deferred3_0;
     let deferred3_1;
     try {
@@ -309,18 +334,22 @@ module.exports.validateCapabilities = function(input) {
     }
 };
 
-function __wbg_adapter_54(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h1ed9ddf46f2cacfa(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h13019d5ee70bd6b6(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h13019d5ee70bd6b6(arg0, arg1);
 }
 
-function __wbg_adapter_57(arg0, arg1, arg2) {
-    wasm.closure170_externref_shim(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h69202035a90512ea(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h69202035a90512ea(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_120(arg0, arg1, arg2, arg3) {
-    wasm.closure74_externref_shim(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h07d45d2c9c5e1bbe(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h07d45d2c9c5e1bbe(arg0, arg1, arg2, arg3);
 }
 
+const __wbindgen_enum_Level = ["error", "warn", "info", "debug", "trace"];
+
+const __wbindgen_enum_ReadableStreamType = ["bytes"];
+
 const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
 
 const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
@@ -361,15 +390,22 @@ class AuthFlow {
     }
     /**
      * Start a flow (standalone).
-     * Prefer `pubky.startAuthFlow()` to reuse a façade client.
+     * Prefer `pubky.startAuthFlow()` to reuse a facade client.
      *
      * @param {string} capabilities
      * Comma-separated capabilities, e.g. `"/pub/app/:rw,/priv/foo.txt:r"`.
      * Each entry must be `"<scope>:<actions>"`, where:
-     * - `scope` starts with `/` (e.g. `/pub/example.app/`)
+     * - `scope` starts with `/` (e.g. `/pub/example.com/`)
      * - `actions` is any combo of `r` and/or `w` (order is normalized; `wr` -> `rw`)
      * Empty string is allowed (no scopes).
      *
+     * @param {AuthFlowKind} kind
+     * The kind of authentication flow to perform.
+     * This can either be a sign in or a sign up flow.
+     * Examples:
+     * - `AuthFlowKind.signin()` - Sign in to an existing account.
+     * - `AuthFlowKind.signup(homeserverPublicKey, signupToken)` - Sign up for a new account.
+     *
      * @param {string} [relay]
      * Optional HTTP relay base, e.g. `"https://demo.httprelay.io/link/"`.
      * Defaults to the default Synonym-hosted relay when omitted.
@@ -377,23 +413,26 @@ class AuthFlow {
      * @returns {AuthFlow}
      * A running auth flow. Call `authorizationUrl()` to show the deep link,
      * then `awaitApproval()` to receive a `Session`.
-     * @throws {PubkyJsError}
+     * @throws {PubkyError}
      * - `{ name: "InvalidInput", message: string }` if any capability entry is invalid
      *     or for an invalid relay URL.
      * @example
-     * const flow = AuthFlow.start("/pub/my.app/:rw,/pub/pubky.app/:w");
+     * const flow = AuthFlow.start("/pub/my-cool-app/:rw,/pub/pubky.app/:w");
      * renderQRCode(flow.authorizationUrl());
      * const session = await flow.awaitApproval();
-     * @param {string} capabilities
+     * @param {Capabilities} capabilities
+     * @param {AuthFlowKind} kind
      * @param {string | null} [relay]
      * @returns {AuthFlow}
      */
-    static start(capabilities, relay) {
+    static start(capabilities, kind, relay) {
         const ptr0 = passStringToWasm0(capabilities, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(relay) ? 0 : passStringToWasm0(relay, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        const ret = wasm.authflow_start(ptr0, len0, ptr1, len1);
+        _assertClass(kind, AuthFlowKind);
+        var ptr1 = kind.__destroy_into_raw();
+        var ptr2 = isLikeNone(relay) ? 0 : passStringToWasm0(relay, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.authflow_start(ptr0, len0, ptr1, ptr2, len2);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -408,7 +447,7 @@ class AuthFlow {
      * renderQr(flow.authorizationUrl());
      * @returns {string}
      */
-    authorizationUrl() {
+    get authorizationUrl() {
         let deferred1_0;
         let deferred1_1;
         try {
@@ -426,7 +465,7 @@ class AuthFlow {
      * @returns {Promise<Session>}
      * Resolves when approved; rejects on timeout/cancel/network errors.
      *
-     * @throws {PubkyJsError}
+     * @throws {PubkyError}
      * - `RequestError` if relay/network fails
      * - `AuthenticationError` if approval is denied/invalid
      * @returns {Promise<Session>}
@@ -442,7 +481,7 @@ class AuthFlow {
      * @returns {Promise<AuthToken>}
      * Resolves when approved; rejects on timeout/cancel/network errors.
      *
-     * @throws {PubkyJsError}
+     * @throws {PubkyError}
      * - `RequestError` if relay/network fails
      * @returns {Promise<AuthToken>}
      */
@@ -454,7 +493,7 @@ class AuthFlow {
     /**
      * Non-blocking single poll step (advanced UIs).
      *
-     * @returns {Promise<Session|null>} A session if the approval arrived, otherwise `null`.
+     * @returns {Promise<Session|undefined>} A session if the approval arrived, otherwise `undefined`.
      * @returns {Promise<Session | undefined>}
      */
     tryPollOnce() {
@@ -462,7 +501,85 @@ class AuthFlow {
         return ret;
     }
 }
-module.exports.AuthFlow = AuthFlow;
+if (Symbol.dispose) AuthFlow.prototype[Symbol.dispose] = AuthFlow.prototype.free;
+
+exports.AuthFlow = AuthFlow;
+
+const AuthFlowKindFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_authflowkind_free(ptr >>> 0, 1));
+/**
+ * The kind of authentication flow to perform.
+ * This can either be a sign in or a sign up flow.
+ */
+class AuthFlowKind {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AuthFlowKind.prototype);
+        obj.__wbg_ptr = ptr;
+        AuthFlowKindFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AuthFlowKindFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_authflowkind_free(ptr, 0);
+    }
+    /**
+     * Create a sign in flow.
+     * @returns {AuthFlowKind}
+     */
+    static signin() {
+        const ret = wasm.authflowkind_signin();
+        return AuthFlowKind.__wrap(ret);
+    }
+    /**
+     * Create a sign up flow.
+     * # Arguments
+     * * `homeserver_public_key` - The public key of the homeserver to sign up on.
+     * * `signup_token` - The signup token to use for the signup flow. This is optional.
+     * @param {PublicKey} homeserver_public_key
+     * @param {string | null} [signup_token]
+     * @returns {AuthFlowKind}
+     */
+    static signup(homeserver_public_key, signup_token) {
+        _assertClass(homeserver_public_key, PublicKey);
+        var ptr0 = isLikeNone(signup_token) ? 0 : passStringToWasm0(signup_token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.authflowkind_signup(homeserver_public_key.__wbg_ptr, ptr0, len0);
+        return AuthFlowKind.__wrap(ret);
+    }
+    /**
+     * Get the intent of the authentication flow.
+     * # Returns
+     * * `"signin"` - If the authentication flow is a sign in flow.
+     * * `"signup"` - If the authentication flow is a sign up flow.
+     * @returns {string}
+     */
+    get intent() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.authflowkind_intent(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) AuthFlowKind.prototype[Symbol.dispose] = AuthFlowKind.prototype.free;
+
+exports.AuthFlowKind = AuthFlowKind;
 
 const AuthTokenFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -563,12 +680,11 @@ class AuthToken {
      *
      * Use `.z32()` on the returned `PublicKey` to get the string form.
      *
-     * ```js
-     * const who = token.publicKey().z32();
-     * ```
+     * @example
+     * const who = sessionInfo.publicKey.z32();
      * @returns {PublicKey}
      */
-    publicKey() {
+    get publicKey() {
         const ret = wasm.authtoken_publicKey(this.__wbg_ptr);
         return PublicKey.__wrap(ret);
     }
@@ -580,12 +696,14 @@ class AuthToken {
      *
      * Returns: `string[]`, where each item is the canonical entry `"<scope>:<actions>"`.
      *
-     * Example entry: `"/pub/my.app/:rw"`
-     * @returns {Array<any>}
+     * Example entry: `"/pub/my-cool-app/:rw"`
+     * @returns {string[]}
      */
-    capabilities() {
+    get capabilities() {
         const ret = wasm.authtoken_capabilities(this.__wbg_ptr);
-        return ret;
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
      * Serialize the token to a `Uint8Array` in its **canonical** (postcard) binary format.
@@ -603,15 +721,17 @@ class AuthToken {
         return ret;
     }
 }
-module.exports.AuthToken = AuthToken;
+if (Symbol.dispose) AuthToken.prototype[Symbol.dispose] = AuthToken.prototype.free;
+
+exports.AuthToken = AuthToken;
 
 const ClientFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_client_free(ptr >>> 0, 1));
 /**
- * Low-level HTTP bridge used by the Pubky façade and actors.
+ * Low-level HTTP bridge used by the Pubky facade and actors.
  *
- * - Supports `pubky://<user-z32>/<abs-path>` and `http(s)://` URLs.
+ * - Supports `http(s)://` URLs targeting Pubky or ICANN hosts.
  * - In browsers/undici, passes `credentials: "include"` to send cookies.
  */
 class Client {
@@ -643,7 +763,7 @@ class Client {
      * `{ pkarr?: { relays?: string[], request_timeout?: number } }`.
      *
      * @returns {Client}
-     * A configured low-level client. Prefer `new Pubky().client()` unless you
+     * A configured low-level client. Prefer `new Pubky().client` unless you
      * need custom relays/timeouts.
      *
      * @throws {InvalidInput}
@@ -668,8 +788,7 @@ class Client {
     /**
      * Create a client wired for **local testnet**.
      *
-     * Sets PKARR relays to `http://<host>:15411/` and enables WASM `pubky://`
-     * mapping for that host.
+     * Configures PKARR relays for the testnet and remembers the hostname for WASM `_pubky` mapping.
      *
      * @param {string} [host="localhost"]
      * Testnet hostname or IP.
@@ -696,18 +815,18 @@ class Client {
         return Client.__wrap(ret[0]);
     }
     /**
-     * Perform a raw fetch. Works with `pubky://` or `http(s)://` URLs.
+     * Perform a raw fetch. Works with `http(s)://` URLs.
      *
      * @param {string} url
-     * @param {RequestInit=} init Standard fetch options; `credentials: "include"` recommended for session I/O.
+     * @param {RequestInit} init Standard fetch options; `credentials: "include"` recommended for session I/O.
      * @returns {Promise<Response>}
      *
      * @example
-     * const client = pubky.client();
-     * const res = await client.fetch(`pubky://${user}/pub/app/file.txt`, { method: "PUT", body: "hi", credentials: "include" });
+     * const client = pubky.client;
+     * const res = await client.fetch(`https://_pubky.${user}/pub/app/file.txt`, { method: "PUT", body: "hi", credentials: "include" });
      * @param {string} url
-     * @param {any | null} [init]
-     * @returns {Promise<Promise<any>>}
+     * @param {RequestInit | null} [init]
+     * @returns {Promise<Response>}
      */
     fetch(url, init) {
         const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -716,80 +835,230 @@ class Client {
         return ret;
     }
 }
-module.exports.Client = Client;
+if (Symbol.dispose) Client.prototype[Symbol.dispose] = Client.prototype.free;
 
-const KeypairFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_keypair_free(ptr >>> 0, 1));
+exports.Client = Client;
 
-class Keypair {
+const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
 
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Keypair.prototype);
-        obj.__wbg_ptr = ptr;
-        KeypairFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+class IntoUnderlyingByteSource {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        KeypairFinalization.unregister(this);
+        IntoUnderlyingByteSourceFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_keypair_free(ptr, 0);
+        wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
     }
     /**
-     * Generate a random [Keypair]
-     * @returns {Keypair}
+     * @returns {ReadableStreamType}
      */
-    static random() {
-        const ret = wasm.keypair_random();
-        return Keypair.__wrap(ret);
+    get type() {
+        const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
+        return __wbindgen_enum_ReadableStreamType[ret];
     }
     /**
-     * Generate a [Keypair] from a secret key.
-     * @param {Uint8Array} secret_key
-     * @returns {Keypair}
+     * @returns {number}
      */
-    static fromSecretKey(secret_key) {
-        const ptr0 = passArray8ToWasm0(secret_key, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.keypair_fromSecretKey(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Keypair.__wrap(ret[0]);
+    get autoAllocateChunkSize() {
+        const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Returns the secret key of this keypair.
-     * @returns {Uint8Array}
+     * @param {ReadableByteStreamController} controller
      */
-    secretKey() {
-        const ret = wasm.keypair_secretKey(this.__wbg_ptr);
-        return ret;
+    start(controller) {
+        wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
     }
     /**
-     * Returns the [PublicKey] of this keypair.
-     * @returns {PublicKey}
+     * @param {ReadableByteStreamController} controller
+     * @returns {Promise<any>}
      */
-    publicKey() {
-        const ret = wasm.keypair_publicKey(this.__wbg_ptr);
-        return PublicKey.__wrap(ret);
+    pull(controller) {
+        const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
+        return ret;
+    }
+    cancel() {
+        const ptr = this.__destroy_into_raw();
+        wasm.intounderlyingbytesource_cancel(ptr);
+    }
+}
+if (Symbol.dispose) IntoUnderlyingByteSource.prototype[Symbol.dispose] = IntoUnderlyingByteSource.prototype.free;
+
+exports.IntoUnderlyingByteSource = IntoUnderlyingByteSource;
+
+const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));
+
+class IntoUnderlyingSink {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntoUnderlyingSinkFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_intounderlyingsink_free(ptr, 0);
     }
     /**
-     * Create a recovery file for this keypair (encrypted with the given passphrase).
-     * @param {string} passphrase
-     * @returns {Uint8Array}
+     * @param {any} chunk
+     * @returns {Promise<any>}
      */
-    createRecoveryFile(passphrase) {
-        const ptr0 = passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.keypair_createRecoveryFile(this.__wbg_ptr, ptr0, len0);
+    write(chunk) {
+        const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
+        return ret;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    close() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.intounderlyingsink_close(ptr);
+        return ret;
+    }
+    /**
+     * @param {any} reason
+     * @returns {Promise<any>}
+     */
+    abort(reason) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.intounderlyingsink_abort(ptr, reason);
+        return ret;
+    }
+}
+if (Symbol.dispose) IntoUnderlyingSink.prototype[Symbol.dispose] = IntoUnderlyingSink.prototype.free;
+
+exports.IntoUnderlyingSink = IntoUnderlyingSink;
+
+const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));
+
+class IntoUnderlyingSource {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IntoUnderlyingSource.prototype);
+        obj.__wbg_ptr = ptr;
+        IntoUnderlyingSourceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntoUnderlyingSourceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_intounderlyingsource_free(ptr, 0);
+    }
+    /**
+     * @param {ReadableStreamDefaultController} controller
+     * @returns {Promise<any>}
+     */
+    pull(controller) {
+        const ret = wasm.intounderlyingsource_pull(this.__wbg_ptr, controller);
+        return ret;
+    }
+    cancel() {
+        const ptr = this.__destroy_into_raw();
+        wasm.intounderlyingsource_cancel(ptr);
+    }
+}
+if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
+
+exports.IntoUnderlyingSource = IntoUnderlyingSource;
+
+const KeypairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_keypair_free(ptr >>> 0, 1));
+
+class Keypair {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Keypair.prototype);
+        obj.__wbg_ptr = ptr;
+        KeypairFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KeypairFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_keypair_free(ptr, 0);
+    }
+    /**
+     * Generate a random [Keypair]
+     * @returns {Keypair}
+     */
+    static random() {
+        const ret = wasm.keypair_random();
+        return Keypair.__wrap(ret);
+    }
+    /**
+     * Generate a [Keypair] from a secret key.
+     * @param {Uint8Array} secret_key
+     * @returns {Keypair}
+     */
+    static fromSecretKey(secret_key) {
+        const ptr0 = passArray8ToWasm0(secret_key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.keypair_fromSecretKey(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Keypair.__wrap(ret[0]);
+    }
+    /**
+     * Returns the secret key of this keypair.
+     * @returns {Uint8Array}
+     */
+    secretKey() {
+        const ret = wasm.keypair_secretKey(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the [PublicKey] of this keypair.
+     *
+     * Use `.z32()` on the returned `PublicKey` to get the string form.
+     *
+     * @example
+     * const who = keypair.publicKey.z32();
+     * @returns {PublicKey}
+     */
+    get publicKey() {
+        const ret = wasm.keypair_publicKey(this.__wbg_ptr);
+        return PublicKey.__wrap(ret);
+    }
+    /**
+     * Create a recovery file for this keypair (encrypted with the given passphrase).
+     * @param {string} passphrase
+     * @returns {Uint8Array}
+     */
+    createRecoveryFile(passphrase) {
+        const ptr0 = passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.keypair_createRecoveryFile(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
@@ -810,7 +1079,9 @@ class Keypair {
         return Keypair.__wrap(ret[0]);
     }
 }
-module.exports.Keypair = Keypair;
+if (Symbol.dispose) Keypair.prototype[Symbol.dispose] = Keypair.prototype.free;
+
+exports.Keypair = Keypair;
 
 const PkdnsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -868,9 +1139,9 @@ class Pkdns {
      * Resolve the homeserver for a given public key (read-only).
      *
      * @param {PublicKey} user
-     * @returns {Promise<string|undefined>} Homeserver public key (z32) or `undefined` if not found.
+     * @returns {Promise<PublicKey|undefined>} Homeserver public key or `undefined` if not found.
      * @param {PublicKey} pubky
-     * @returns {Promise<string | undefined>}
+     * @returns {Promise<PublicKey | undefined>}
      */
     getHomeserverOf(pubky) {
         _assertClass(pubky, PublicKey);
@@ -880,15 +1151,15 @@ class Pkdns {
     /**
      * Resolve the homeserver for **this** user (requires keypair).
      *
-     * @returns {Promise<string|undefined>} Homeserver public key (z32) or `undefined` if not found.
-     * @returns {Promise<string | undefined>}
+     * @returns {Promise<PublicKey|undefined>} Homeserver public key or `undefined` if not found.
+     * @returns {Promise<PublicKey | undefined>}
      */
     getHomeserver() {
         const ret = wasm.pkdns_getHomeserver(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Republish homeserver if record is missing/stale.
+     * Force publish homeserver immediately (even if fresh).
      *
      * Requires keypair or to be signer bound.
      *
@@ -907,7 +1178,7 @@ class Pkdns {
         return ret;
     }
     /**
-     * Force publish homeserver immediately (even if fresh).
+     * Republish homeserver if record is missing/stale.
      *
      * Requires keypair or to be signer bound.
      *
@@ -926,7 +1197,9 @@ class Pkdns {
         return ret;
     }
 }
-module.exports.Pkdns = Pkdns;
+if (Symbol.dispose) Pkdns.prototype[Symbol.dispose] = Pkdns.prototype.free;
+
+exports.Pkdns = Pkdns;
 
 const PubkyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -956,10 +1229,10 @@ class Pubky {
         wasm.__wbg_pubky_free(ptr, 0);
     }
     /**
-     * Create a Pubky façade wired for **mainnet** defaults (public relays).
+     * Create a Pubky facade wired for **mainnet** defaults (public relays).
      *
      * @returns {Pubky}
-     * A new façade instance. Use this to create signers, start auth flows, etc.
+     * A new facade instance. Use this to create signers, start auth flows, etc.
      *
      * @example
      * const pubky = new Pubky();
@@ -975,7 +1248,7 @@ class Pubky {
         return this;
     }
     /**
-     * Create a Pubky façade preconfigured for a **local testnet**.
+     * Create a Pubky facade preconfigured for a **local testnet**.
      *
      * If `host` is provided, PKARR and HTTP endpoints are derived as `http://<host>:ports/...`.
      * If omitted, `"localhost"` is assumed (handy for `cargo install pubky-testnet`).
@@ -999,7 +1272,7 @@ class Pubky {
         return Pubky.__wrap(ret[0]);
     }
     /**
-     * Wrap an existing configured HTTP client into a Pubky façade.
+     * Wrap an existing configured HTTP client into a Pubky facade.
      *
      * @param {Client} client A previously constructed client.
      * @returns {Pubky}
@@ -1021,34 +1294,41 @@ class Pubky {
      * Provide a **capabilities string** and (optionally) a relay base URL.
      * The capabilities string is a comma-separated list of entries:
      * `"<scope>:<actions>"`, where:
-     * - `scope` starts with `/` (e.g. `/pub/example.app/`).
+     * - `scope` starts with `/` (e.g. `/pub/example.com/`).
      * - `actions` is any combo of `r` and/or `w` (order normalized; `wr` -> `rw`).
      * Pass `""` for no scopes (read-only public session).
      *
      * @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.
+     * Examples:
+     * - `AuthFlowKind.signin()` - Sign in to an existing account.
+     * - `AuthFlowKind.signup(homeserverPublicKey, signupToken)` - Sign up for a new account.
      * @param {string=} relay Optional HTTP relay base (e.g. `"https://…/link/"`).
      * @returns {AuthFlow}
-     * A running auth flow. Call `authorizationUrl()` to show a QR/deeplink,
+     * A running auth flow. Show `authorizationUrl` as QR/deeplink,
      * then `awaitApproval()` to obtain a `Session`.
      *
-     * @throws {PubkyJsError}
+     * @throws {PubkyError}
      * - `{ name: "InvalidInput" }` for malformed capabilities or bad relay URL
      * - `{ name: "RequestError" }` if the flow cannot be started (network/relay)
      *
      * @example
-     * const flow = pubky.startAuthFlow("/pub/my.app/:rw");
-     * renderQr(flow.authorizationUrl());
+     * const flow = pubky.startAuthFlow("/pub/my-cool-app/:rw");
+     * renderQr(flow.authorizationUrl);
      * const session = await flow.awaitApproval();
-     * @param {string} capabilities
+     * @param {Capabilities} capabilities
+     * @param {AuthFlowKind} kind
      * @param {string | null} [relay]
      * @returns {AuthFlow}
      */
-    startAuthFlow(capabilities, relay) {
+    startAuthFlow(capabilities, kind, relay) {
         const ptr0 = passStringToWasm0(capabilities, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(relay) ? 0 : passStringToWasm0(relay, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        const ret = wasm.pubky_startAuthFlow(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        _assertClass(kind, AuthFlowKind);
+        var ptr1 = kind.__destroy_into_raw();
+        var ptr2 = isLikeNone(relay) ? 0 : passStringToWasm0(relay, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.pubky_startAuthFlow(this.__wbg_ptr, ptr0, len0, ptr1, ptr2, len2);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -1068,8 +1348,7 @@ class Pubky {
      */
     signer(keypair) {
         _assertClass(keypair, Keypair);
-        var ptr0 = keypair.__destroy_into_raw();
-        const ret = wasm.pubky_signer(this.__wbg_ptr, ptr0);
+        const ret = wasm.pubky_signer(this.__wbg_ptr, keypair.__wbg_ptr);
         return Signer.__wrap(ret);
     }
     /**
@@ -1081,27 +1360,27 @@ class Pubky {
      * @returns {PublicStorage}
      *
      * @example
-     * const pub = pubky.publicStorage();
-     * const text = await pub.getText(`${userPk.z32()}/pub/example.com/hello.txt`);
+     * const text = await pubky.publicStorage.getText(`${userPk.z32()}/pub/example.com/hello.txt`);
      * @returns {PublicStorage}
      */
-    publicStorage() {
-        const ret = wasm.pubky_publicStorage(this.__wbg_ptr);
+    get publicStorage() {
+        const ret = wasm.pubky_client(this.__wbg_ptr);
         return PublicStorage.__wrap(ret);
     }
     /**
-     * Read-only PKDNS (Pkarr) resolver.
+     * Resolve the homeserver for a given public key (read-only).
      *
-     * @returns {Pkdns}
+     * Uses an internal read-only Pkdns actor.
      *
-     * @example
-     * const dns = pubky.pkdns();
-     * const homeserver = await dns.getHomeserverOf(userPk);
-     * @returns {Pkdns}
+     * @param {PublicKey} user
+     * @returns {Promise<PublicKey|undefined>} Homeserver public key (z32) or `undefined` if not found.
+     * @param {PublicKey} user_public_key
+     * @returns {Promise<PublicKey | undefined>}
      */
-    pkdns() {
-        const ret = wasm.pubky_pkdns(this.__wbg_ptr);
-        return Pkdns.__wrap(ret);
+    getHomeserverOf(user_public_key) {
+        _assertClass(user_public_key, PublicKey);
+        const ret = wasm.pubky_getHomeserverOf(this.__wbg_ptr, user_public_key.__wbg_ptr);
+        return ret;
     }
     /**
      * Access the underlying HTTP client (advanced).
@@ -1110,15 +1389,38 @@ class Pubky {
      * Use this for low-level `fetch()` calls or testing with raw URLs.
      *
      * @example
-     * const r = await pubky.client().fetch(`pubky://${user}/pub/app/file.txt`, { credentials: "include" });
+     * const r = await pubky.client.fetch(`pubky://${user}/pub/app/file.txt`, { credentials: "include" });
      * @returns {Client}
      */
-    client() {
+    get client() {
         const ret = wasm.pubky_client(this.__wbg_ptr);
         return Client.__wrap(ret);
     }
+    /**
+     * Restore a session from a previously exported snapshot, using this instance's client.
+     *
+     * This does **not** read or write any secrets. It revalidates the session metadata with
+     * the server using the browser-managed HTTP-only cookie that must still be present.
+     *
+     * @param {string} exported A string produced by `session.export()`.
+     * @returns {Promise<Session>}
+     * A rehydrated session bound to this SDK's HTTP client.
+     *
+     * @example
+     * const restored = await pubky.restoreSession(localStorage.getItem("pubky-session")!);
+     * @param {string} exported
+     * @returns {Promise<Session>}
+     */
+    restoreSession(exported) {
+        const ptr0 = passStringToWasm0(exported, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pubky_restoreSession(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
 }
-module.exports.Pubky = Pubky;
+if (Symbol.dispose) Pubky.prototype[Symbol.dispose] = Pubky.prototype.free;
+
+exports.Pubky = Pubky;
 
 const PublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1184,7 +1486,9 @@ class PublicKey {
         return PublicKey.__wrap(ret[0]);
     }
 }
-module.exports.PublicKey = PublicKey;
+if (Symbol.dispose) PublicKey.prototype[Symbol.dispose] = PublicKey.prototype.free;
+
+exports.PublicKey = PublicKey;
 
 const PublicStorageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1226,15 +1530,15 @@ class PublicStorage {
         return this;
     }
     /**
-     * List a directory. Results are `pubky://…` absolute URLs.
+     * List a directory. Results are `pubky://…` identifier URLs.
      *
-     * @param {string} address Addressed directory (must end with `/`).
+     * @param {Address} address Addressed directory (must end with `/`).
      * @param {string|null=} cursor Optional suffix or full URL to start **after**.
      * @param {boolean=} reverse Default `false`. When `true`, newest/lexicographically-last first.
      * @param {number=} limit Optional result limit.
      * @param {boolean=} shallow Default `false`. When `true`, lists only first-level entries.
      * @returns {Promise<string[]>}
-     * @param {string} address
+     * @param {Address} address
      * @param {string | null} [cursor]
      * @param {boolean | null} [reverse]
      * @param {number | null} [limit]
@@ -1249,12 +1553,26 @@ class PublicStorage {
         const ret = wasm.publicstorage_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;
     }
+    /**
+     * Perform a streaming `GET` and expose the raw `Response` object.
+     *
+     * @param {Address} address
+     * @returns {Promise<Response>}
+     * @param {Address} address
+     * @returns {Promise<Response>}
+     */
+    get(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.publicstorage_get(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * Fetch bytes from an addressed path.
      *
-     * @param {string} address
+     * @param {Address} address
      * @returns {Promise<Uint8Array>}
-     * @param {string} address
+     * @param {Address} address
      * @returns {Promise<Uint8Array>}
      */
     getBytes(address) {
@@ -1266,9 +1584,9 @@ class PublicStorage {
     /**
      * Fetch text from an addressed path as UTF-8 text.
      *
-     * @param {string} address
+     * @param {Address} address
      * @returns {Promise<string>}
-     * @param {string} address
+     * @param {Address} address
      * @returns {Promise<string>}
      */
     getText(address) {
@@ -1280,9 +1598,9 @@ class PublicStorage {
     /**
      * Fetch JSON from an addressed path.
      *
-     * @param {string} address `"<user-z32>/pub/.../file.json"` or `pubky://<user>/pub/...`.
+     * @param {Address} address `"pubky<user>/pub/.../file.json"` (preferred) or `pubky://<user>/pub/...`.
      * @returns {Promise<any>}
-     * @param {string} address
+     * @param {Address} address
      * @returns {Promise<any>}
      */
     getJson(address) {
@@ -1294,9 +1612,9 @@ class PublicStorage {
     /**
      * Check if a path exists.
      *
-     * @param {string} address
+     * @param {Address} address
      * @returns {Promise<boolean>}
-     * @param {string} address
+     * @param {Address} address
      * @returns {Promise<boolean>}
      */
     exists(address) {
@@ -1308,10 +1626,10 @@ class PublicStorage {
     /**
      * Get metadata for an address
      *
-     * @param {string} address `"<user-z32>/pub/.../file.json"` or `pubky://<user>/pub/...`.
+     * @param {Address} address `"pubky<user>/pub/.../file.json"` (preferred) or `pubky://<user>/pub/...`.
      * @returns {Promise<ResourceStats|undefined>} `undefined` if the resource does not exist.
-     * @throws {PubkyJsError} On invalid input or transport/server errors.
-     * @param {string} address
+     * @throws {PubkyError} On invalid input or transport/server errors.
+     * @param {Address} address
      * @returns {Promise<ResourceStats | undefined>}
      */
     stats(address) {
@@ -1321,14 +1639,81 @@ class PublicStorage {
         return ret;
     }
 }
-module.exports.PublicStorage = PublicStorage;
+if (Symbol.dispose) PublicStorage.prototype[Symbol.dispose] = PublicStorage.prototype.free;
+
+exports.PublicStorage = PublicStorage;
+
+const SeedExportDeepLinkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_seedexportdeeplink_free(ptr >>> 0, 1));
+
+class SeedExportDeepLink {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SeedExportDeepLink.prototype);
+        obj.__wbg_ptr = ptr;
+        SeedExportDeepLinkFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SeedExportDeepLinkFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_seedexportdeeplink_free(ptr, 0);
+    }
+    /**
+     * @param {string} url
+     * @returns {SeedExportDeepLink}
+     */
+    static parse(url) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.seedexportdeeplink_parse(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SeedExportDeepLink.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get secret() {
+        const ret = wasm.seedexportdeeplink_secret(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.seedexportdeeplink_toString(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) SeedExportDeepLink.prototype[Symbol.dispose] = SeedExportDeepLink.prototype.free;
+
+exports.SeedExportDeepLink = SeedExportDeepLink;
 
 const SessionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_session_free(ptr >>> 0, 1));
 /**
  * An authenticated context “as the user”.
- * - Use `storage()` for reads/writes (absolute paths like `/pub/app/file.txt`)
+ * - Use `storage` for reads/writes (absolute paths like `/pub/app/file.txt`)
  * - Cookie is managed automatically by the underlying fetch client
  */
 class Session {
@@ -1358,7 +1743,7 @@ class Session {
      * @returns {SessionInfo}
      * @returns {SessionInfo}
      */
-    info() {
+    get info() {
         const ret = wasm.session_info(this.__wbg_ptr);
         return SessionInfo.__wrap(ret);
     }
@@ -1368,24 +1753,73 @@ class Session {
      * @returns {SessionStorage}
      * @returns {SessionStorage}
      */
-    storage() {
+    get storage() {
         const ret = wasm.session_storage(this.__wbg_ptr);
         return SessionStorage.__wrap(ret);
     }
     /**
      * Invalidate the session on the server (clears server cookie).
-     * It also consumes this JS/Wasm Session. Further calls will fail.
+     * Further calls to storage API will fail.
      *
      * @returns {Promise<void>}
      * @returns {Promise<void>}
      */
     signout() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.session_signout(ptr);
+        const ret = wasm.session_signout(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Export the session metadata so it can be restored after a tab refresh.
+     *
+     * The export string contains **no secrets**; it only serializes the public `SessionInfo`.
+     * Browsers remain responsible for persisting the HTTP-only session cookie.
+     *
+     * @returns {string}
+     * A base64 string to store (e.g. in `localStorage`).
+     * @returns {string}
+     */
+    export() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.session_export(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);
+        }
+    }
+    /**
+     * Restore a session from an `export()` string.
+     *
+     * The HTTP-only cookie must still be present in the browser; this function does not
+     * read or write any secrets.
+     *
+     * @param {string} exported
+     * A string produced by `session.export()`.
+     * @param {Client=} client
+     * Optional client to reuse transport configuration.
+     * @returns {Promise<Session>}
+     * @param {string} exported
+     * @param {Client | null} [client]
+     * @returns {Promise<Session>}
+     */
+    static restore(exported, client) {
+        const ptr0 = passStringToWasm0(exported, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ptr1 = 0;
+        if (!isLikeNone(client)) {
+            _assertClass(client, Client);
+            ptr1 = client.__destroy_into_raw();
+        }
+        const ret = wasm.session_restore(ptr0, len0, ptr1);
         return ret;
     }
 }
-module.exports.Session = Session;
+if (Symbol.dispose) Session.prototype[Symbol.dispose] = Session.prototype.free;
+
+exports.Session = Session;
 
 const SessionInfoFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1417,10 +1851,15 @@ class SessionInfo {
     /**
      * The user’s public key for this session.
      *
+     * Use `.z32()` on the returned `PublicKey` to get the string form.
+     *
      * @returns {PublicKey}
+     *
+     * @example
+     * const who = sessionInfo.publicKey.z32();
      * @returns {PublicKey}
      */
-    publicKey() {
+    get publicKey() {
         const ret = wasm.sessioninfo_publicKey(this.__wbg_ptr);
         return PublicKey.__wrap(ret);
     }
@@ -1430,14 +1869,16 @@ class SessionInfo {
      * @returns {string[]} Normalized capability entries (e.g. `"/pub/app/:rw"`).
      * @returns {string[]}
      */
-    capabilities() {
+    get capabilities() {
         const ret = wasm.sessioninfo_capabilities(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
 }
-module.exports.SessionInfo = SessionInfo;
+if (Symbol.dispose) SessionInfo.prototype[Symbol.dispose] = SessionInfo.prototype.free;
+
+exports.SessionInfo = SessionInfo;
 
 const SessionStorageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1469,13 +1910,13 @@ class SessionStorage {
     /**
      * List a directory (absolute session path). Returns `pubky://…` URLs.
      *
-     * @param {string} path Must end with `/`.
+     * @param {Path} path Must end with `/`.
      * @param {string|null=} cursor Optional suffix or full URL to start **after**.
      * @param {boolean=} reverse Default `false`.
      * @param {number=} limit Optional result limit.
      * @param {boolean=} shallow Default `false`.
      * @returns {Promise<string[]>}
-     * @param {string} path
+     * @param {Path} path
      * @param {string | null} [cursor]
      * @param {boolean | null} [reverse]
      * @param {number | null} [limit]
@@ -1490,12 +1931,26 @@ 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;
     }
+    /**
+     * GET a streaming response for an absolute session path.
+     *
+     * @param {Path} path
+     * @returns {Promise<Response>}
+     * @param {Path} path
+     * @returns {Promise<Response>}
+     */
+    get(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sessionstorage_get(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * GET bytes from an absolute session path.
      *
-     * @param {string} path
+     * @param {Path} path
      * @returns {Promise<Uint8Array>}
-     * @param {string} path
+     * @param {Path} path
      * @returns {Promise<Uint8Array>}
      */
     getBytes(path) {
@@ -1507,9 +1962,9 @@ class SessionStorage {
     /**
      * GET text from an absolute session path.
      *
-     * @param {string} path
+     * @param {Path} path
      * @returns {Promise<string>}
-     * @param {string} path
+     * @param {Path} path
      * @returns {Promise<string>}
      */
     getText(path) {
@@ -1521,13 +1976,13 @@ class SessionStorage {
     /**
      * GET JSON from an absolute session path.
      *
-     * @param {string} path
+     * @param {Path} path
      * @returns {Promise<any>}
-     * @param {string} addr
+     * @param {Path} path
      * @returns {Promise<any>}
      */
-    getJson(addr) {
-        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    getJson(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.sessionstorage_getJson(this.__wbg_ptr, ptr0, len0);
         return ret;
@@ -1535,9 +1990,9 @@ class SessionStorage {
     /**
      * Check existence.
      *
-     * @param {string} path
+     * @param {Path} path
      * @returns {Promise<boolean>}
-     * @param {string} path
+     * @param {Path} path
      * @returns {Promise<boolean>}
      */
     exists(path) {
@@ -1549,10 +2004,10 @@ class SessionStorage {
     /**
      * Get metadata for an absolute, session-scoped path (e.g. `"/pub/app/file.json"`).
      *
-     * @param {string} path Absolute path under your user (starts with `/`).
+     * @param {Path} path Absolute path under your user (starts with `/`).
      * @returns {Promise<ResourceStats|undefined>} `undefined` if the resource does not exist.
-     * @throws {PubkyJsError} On invalid input or transport/server errors.
-     * @param {string} path
+     * @throws {PubkyError} On invalid input or transport/server errors.
+     * @param {Path} path
      * @returns {Promise<ResourceStats | undefined>}
      */
     stats(path) {
@@ -1564,10 +2019,10 @@ class SessionStorage {
     /**
      * PUT binary at an absolute session path.
      *
-     * @param {string} path
+     * @param {Path} path
      * @param {Uint8Array} bytes
      * @returns {Promise<void>}
-     * @param {string} path
+     * @param {Path} path
      * @param {Uint8Array} body
      * @returns {Promise<void>}
      */
@@ -1582,10 +2037,10 @@ class SessionStorage {
     /**
      * PUT text at an absolute session path.
      *
-     * @param {string} path
+     * @param {Path} path
      * @param {string} text
      * @returns {Promise<void>}
-     * @param {string} path
+     * @param {Path} path
      * @param {string} body
      * @returns {Promise<void>}
      */
@@ -1600,10 +2055,10 @@ class SessionStorage {
     /**
      * PUT JSON at an absolute session path.
      *
-     * @param {string} path Absolute path (e.g. `"/pub/app/data.json"`).
+     * @param {Path} path Absolute path (e.g. `"/pub/app/data.json"`).
      * @param {any} value JSON-serializable value.
      * @returns {Promise<void>}
-     * @param {string} path
+     * @param {Path} path
      * @param {any} body
      * @returns {Promise<void>}
      */
@@ -1616,9 +2071,9 @@ class SessionStorage {
     /**
      * Delete a path (file or empty directory).
      *
-     * @param {string} path
+     * @param {Path} path
      * @returns {Promise<void>}
-     * @param {string} path
+     * @param {Path} path
      * @returns {Promise<void>}
      */
     delete(path) {
@@ -1628,7 +2083,9 @@ class SessionStorage {
         return ret;
     }
 }
-module.exports.SessionStorage = SessionStorage;
+if (Symbol.dispose) SessionStorage.prototype[Symbol.dispose] = SessionStorage.prototype.free;
+
+exports.SessionStorage = SessionStorage;
 
 const SignerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1672,7 +2129,10 @@ class Signer {
     static fromKeypair(keypair) {
         _assertClass(keypair, Keypair);
         const ret = wasm.signer_fromKeypair(keypair.__wbg_ptr);
-        return Signer.__wrap(ret);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Signer.__wrap(ret[0]);
     }
     /**
      * Get the public key of this signer.
@@ -1680,7 +2140,7 @@ class Signer {
      * @returns {PublicKey}
      * @returns {PublicKey}
      */
-    publicKey() {
+    get publicKey() {
         const ret = wasm.signer_publicKey(this.__wbg_ptr);
         return PublicKey.__wrap(ret);
     }
@@ -1693,7 +2153,7 @@ class Signer {
      * @param {string|null} signupToken Invite/registration token or `null`.
      * @returns {Promise<Session>}
      *
-     * @throws {PubkyJsError}
+     * @throws {PubkyError}
      * - `AuthenticationError` (bad/expired token)
      * - `RequestError` (network/server)
      * @param {PublicKey} homeserver
@@ -1714,7 +2174,7 @@ class Signer {
      *
      * @returns {Promise<Session>}
      *
-     * @throws {PubkyJsError}
+     * @throws {PubkyError}
      * @returns {Promise<Session>}
      */
     signin() {
@@ -1748,21 +2208,235 @@ class Signer {
      * Get a PKDNS actor bound to this signer's client & keypair (publishing enabled).
      *
      * @returns {Pkdns}
+     *
+     * @example
+     * await signer.pkdns.publishHomeserverIfStale(homeserverPk);
      * @returns {Pkdns}
      */
-    pkdns() {
+    get pkdns() {
         const ret = wasm.signer_pkdns(this.__wbg_ptr);
         return Pkdns.__wrap(ret);
     }
 }
-module.exports.Signer = Signer;
+if (Symbol.dispose) Signer.prototype[Symbol.dispose] = Signer.prototype.free;
+
+exports.Signer = Signer;
+
+const SigninDeepLinkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signindeeplink_free(ptr >>> 0, 1));
+
+class SigninDeepLink {
 
-module.exports.__wbg_Error_0497d5bdba9362e5 = function(arg0, arg1) {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SigninDeepLink.prototype);
+        obj.__wbg_ptr = ptr;
+        SigninDeepLinkFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SigninDeepLinkFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signindeeplink_free(ptr, 0);
+    }
+    /**
+     * @param {string} url
+     * @returns {SigninDeepLink}
+     */
+    static parse(url) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signindeeplink_parse(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SigninDeepLink.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get capabilities() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signindeeplink_capabilities(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get baseRelayUrl() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signindeeplink_baseRelayUrl(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);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get secret() {
+        const ret = wasm.signindeeplink_secret(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signindeeplink_toString(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) SigninDeepLink.prototype[Symbol.dispose] = SigninDeepLink.prototype.free;
+
+exports.SigninDeepLink = SigninDeepLink;
+
+const SignupDeepLinkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signupdeeplink_free(ptr >>> 0, 1));
+
+class SignupDeepLink {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SignupDeepLink.prototype);
+        obj.__wbg_ptr = ptr;
+        SignupDeepLinkFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignupDeepLinkFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signupdeeplink_free(ptr, 0);
+    }
+    /**
+     * @param {string} url
+     * @returns {SignupDeepLink}
+     */
+    static parse(url) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signupdeeplink_parse(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SignupDeepLink.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get capabilities() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signupdeeplink_capabilities(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get baseRelayUrl() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signupdeeplink_baseRelayUrl(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);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get secret() {
+        const ret = wasm.signupdeeplink_secret(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {PublicKey}
+     */
+    get homeserver() {
+        const ret = wasm.signupdeeplink_homeserver(this.__wbg_ptr);
+        return PublicKey.__wrap(ret);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get signupToken() {
+        const ret = wasm.signupdeeplink_signupToken(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signupdeeplink_toString(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) SignupDeepLink.prototype[Symbol.dispose] = SignupDeepLink.prototype.free;
+
+exports.SignupDeepLink = SignupDeepLink;
+
+exports.__wbg_Error_e83987f665cf5504 = function(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return ret;
 };
 
-module.exports.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+exports.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
     const ret = String(arg1);
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -1770,119 +2444,272 @@ module.exports.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-module.exports.__wbg_abort_18ba44d46e13d7fe = function(arg0) {
-    arg0.abort();
+exports.__wbg___wbindgen_bigint_get_as_i64_f3ebc5a755000afd = function(arg0, arg1) {
+    const v = arg1;
+    const ret = typeof(v) === 'bigint' ? v : undefined;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
+exports.__wbg___wbindgen_boolean_get_6d5a1ee65bab5f68 = function(arg0) {
+    const v = arg0;
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+};
+
+exports.__wbg___wbindgen_debug_string_df47ffb5e35e6763 = function(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+exports.__wbg___wbindgen_in_bb933bd9e1b3bc0f = function(arg0, arg1) {
+    const ret = arg0 in arg1;
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_bigint_cb320707dcd35f0b = function(arg0) {
+    const ret = typeof(arg0) === 'bigint';
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_function_ee8a6c5833c90377 = function(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_null_5e69f72e906cc57c = function(arg0) {
+    const ret = arg0 === null;
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_object_c818261d21f283a4 = function(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_string_fbb76cb2940daafd = function(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
 };
 
-module.exports.__wbg_abort_4198a1129c47f21a = function(arg0, arg1) {
+exports.__wbg___wbindgen_is_undefined_2d472862bd29a478 = function(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+};
+
+exports.__wbg___wbindgen_jsval_eq_6b13ab83478b1c50 = function(arg0, arg1) {
+    const ret = arg0 === arg1;
+    return ret;
+};
+
+exports.__wbg___wbindgen_jsval_loose_eq_b664b38a2f582147 = function(arg0, arg1) {
+    const ret = arg0 == arg1;
+    return ret;
+};
+
+exports.__wbg___wbindgen_number_get_a20bf9b85341449d = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
+exports.__wbg___wbindgen_string_get_e4f06c90489ad01b = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+exports.__wbg___wbindgen_throw_b855445ff6a94295 = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+exports.__wbg__wbg_cb_unref_2454a539ea5790d9 = function(arg0) {
+    arg0._wbg_cb_unref();
+};
+
+exports.__wbg_abort_28ad55c5825b004d = function(arg0, arg1) {
     arg0.abort(arg1);
 };
 
-module.exports.__wbg_append_0342728346e47425 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+exports.__wbg_abort_e7eb059f72f9ed0c = function(arg0) {
+    arg0.abort();
+};
+
+exports.__wbg_append_b577eb3a177bc0fa = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments) };
 
-module.exports.__wbg_arrayBuffer_d58b858456021d7f = function() { return handleError(function (arg0) {
+exports.__wbg_arrayBuffer_b375eccb84b4ddf3 = function() { return handleError(function (arg0) {
     const ret = arg0.arrayBuffer();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_authtoken_new = function(arg0) {
+exports.__wbg_authtoken_new = function(arg0) {
     const ret = AuthToken.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_buffer_a1a27a0dfa70165d = function(arg0) {
+exports.__wbg_body_587542b2fd8e06c0 = function(arg0) {
+    const ret = arg0.body;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_buffer_ccc4520b36d3ccf4 = function(arg0) {
     const ret = arg0.buffer;
     return ret;
 };
 
-module.exports.__wbg_call_f2db6205e5c51dc8 = function() { return handleError(function (arg0, arg1, arg2) {
+exports.__wbg_byobRequest_2344e6975f27456e = function(arg0) {
+    const ret = arg0.byobRequest;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_byteLength_bcd42e4025299788 = function(arg0) {
+    const ret = arg0.byteLength;
+    return ret;
+};
+
+exports.__wbg_byteOffset_ca3a6cf7944b364b = function(arg0) {
+    const ret = arg0.byteOffset;
+    return ret;
+};
+
+exports.__wbg_call_525440f72fbfc0ea = function() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.call(arg1, arg2);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_call_fbe8be8bf6436ce5 = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_call_e762c39fa8ea36bf = function() { return handleError(function (arg0, arg1) {
     const ret = arg0.call(arg1);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_clearTimeout_6222fede17abcb1a = function(arg0) {
+exports.__wbg_cancel_48ab6f9dc366e369 = function(arg0) {
+    const ret = arg0.cancel();
+    return ret;
+};
+
+exports.__wbg_catch_943836faa5d29bfb = function(arg0, arg1) {
+    const ret = arg0.catch(arg1);
+    return ret;
+};
+
+exports.__wbg_clearTimeout_7a42b49784aea641 = function(arg0) {
     const ret = clearTimeout(arg0);
     return ret;
 };
 
-module.exports.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
+exports.__wbg_close_5a6caed3231b68cd = function() { return handleError(function (arg0) {
+    arg0.close();
+}, arguments) };
+
+exports.__wbg_close_6956df845478561a = function() { return handleError(function (arg0) {
+    arg0.close();
+}, arguments) };
+
+exports.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
     const ret = arg0.crypto;
     return ret;
 };
 
-module.exports.__wbg_debug_103948ed4c500577 = function(arg0, arg1, arg2, arg3) {
+exports.__wbg_debug_e55e1461940eb14d = function(arg0, arg1, arg2, arg3) {
     console.debug(arg0, arg1, arg2, arg3);
 };
 
-module.exports.__wbg_done_4d01f352bade43b7 = function(arg0) {
+exports.__wbg_done_2042aa2670fb1db1 = function(arg0) {
     const ret = arg0.done;
     return ret;
 };
 
-module.exports.__wbg_entries_41651c850143b957 = function(arg0) {
+exports.__wbg_enqueue_7b18a650aec77898 = function() { return handleError(function (arg0, arg1) {
+    arg0.enqueue(arg1);
+}, arguments) };
+
+exports.__wbg_entries_e171b586f8f6bdbf = function(arg0) {
     const ret = Object.entries(arg0);
     return ret;
 };
 
-module.exports.__wbg_error_624160881466fd69 = function(arg0, arg1, arg2, arg3) {
+exports.__wbg_error_d8b22cf4e59a6791 = function(arg0, arg1, arg2, arg3) {
     console.error(arg0, arg1, arg2, arg3);
 };
 
-module.exports.__wbg_fetch_0fde801b2e1aa024 = function(arg0) {
+exports.__wbg_fetch_74a3e84ebd2c9a0e = function(arg0) {
     const ret = fetch(arg0);
     return ret;
 };
 
-module.exports.__wbg_fetch_a8e43a4e138dfc93 = function(arg0, arg1) {
+exports.__wbg_fetch_cd778f2325984326 = function(arg0) {
+    const ret = fetch(arg0);
+    return ret;
+};
+
+exports.__wbg_fetch_f8ba0e29a9d6de0d = function(arg0, arg1) {
     const ret = arg0.fetch(arg1);
     return ret;
 };
 
-module.exports.__wbg_fetch_f156d10be9a5c88a = function(arg0) {
-    const ret = fetch(arg0);
+exports.__wbg_from_a4ad7cbddd0d7135 = function(arg0) {
+    const ret = Array.from(arg0);
     return ret;
 };
 
-module.exports.__wbg_getRandomValues_3c9c0d586e575a16 = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_getRandomValues_1c61fac11405ffdc = function() { return handleError(function (arg0, arg1) {
     globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
 }, arguments) };
 
-module.exports.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
     arg0.getRandomValues(arg1);
 }, arguments) };
 
-module.exports.__wbg_get_92470be87867c2e5 = function() { return handleError(function (arg0, arg1) {
-    const ret = Reflect.get(arg0, arg1);
+exports.__wbg_getReader_48e00749fe3f6089 = function() { return handleError(function (arg0) {
+    const ret = arg0.getReader();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_get_a131a44bd1eb6979 = function(arg0, arg1) {
+exports.__wbg_get_7bed016f185add81 = function(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
 };
 
-module.exports.__wbg_has_809e438ee9d787a7 = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_get_done_a0463af43a1fc764 = function(arg0) {
+    const ret = arg0.done;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+};
+
+exports.__wbg_get_efcb449f58ec27c2 = function() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments) };
+
+exports.__wbg_get_value_5ce96c9f81ce7398 = function(arg0) {
+    const ret = arg0.value;
+    return ret;
+};
+
+exports.__wbg_has_787fafc980c3ccdb = function() { return handleError(function (arg0, arg1) {
     const ret = Reflect.has(arg0, arg1);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_headers_0f0cbdc6290b6780 = function(arg0) {
+exports.__wbg_headers_b87d7eaba61c3278 = function(arg0) {
     const ret = arg0.headers;
     return ret;
 };
 
-module.exports.__wbg_info_a1cc312ecc877319 = function(arg0, arg1, arg2, arg3) {
+exports.__wbg_info_68cd5b51ef7e5137 = function(arg0, arg1, arg2, arg3) {
     console.info(arg0, arg1, arg2, arg3);
 };
 
-module.exports.__wbg_instanceof_ArrayBuffer_a8b6f580b363f2bc = function(arg0) {
+exports.__wbg_instanceof_ArrayBuffer_70beb1189ca63b38 = function(arg0) {
     let result;
     try {
         result = arg0 instanceof ArrayBuffer;
@@ -1893,7 +2720,18 @@ module.exports.__wbg_instanceof_ArrayBuffer_a8b6f580b363f2bc = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_instanceof_Headers_8b4c0df841a5ed48 = function(arg0) {
+exports.__wbg_instanceof_Error_a944ec10920129e2 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Error;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+exports.__wbg_instanceof_Headers_e1daf97ed6a469e9 = function(arg0) {
     let result;
     try {
         result = arg0 instanceof Headers;
@@ -1904,7 +2742,7 @@ module.exports.__wbg_instanceof_Headers_8b4c0df841a5ed48 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_instanceof_Map_80cc65041c96417a = function(arg0) {
+exports.__wbg_instanceof_Map_8579b5e2ab5437c7 = function(arg0) {
     let result;
     try {
         result = arg0 instanceof Map;
@@ -1915,7 +2753,7 @@ module.exports.__wbg_instanceof_Map_80cc65041c96417a = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_instanceof_Response_e80ce8b7a2b968d2 = function(arg0) {
+exports.__wbg_instanceof_Response_f4f3e87e07f3135c = function(arg0) {
     let result;
     try {
         result = arg0 instanceof Response;
@@ -1926,7 +2764,7 @@ module.exports.__wbg_instanceof_Response_e80ce8b7a2b968d2 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_instanceof_Uint8Array_ca460677bc155827 = function(arg0) {
+exports.__wbg_instanceof_Uint8Array_20c8e73002f7af98 = function(arg0) {
     let result;
     try {
         result = arg0 instanceof Uint8Array;
@@ -1937,73 +2775,58 @@ module.exports.__wbg_instanceof_Uint8Array_ca460677bc155827 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_isArray_5f090bed72bd4f89 = function(arg0) {
+exports.__wbg_isArray_96e0af9891d0945d = function(arg0) {
     const ret = Array.isArray(arg0);
     return ret;
 };
 
-module.exports.__wbg_isSafeInteger_90d7c4674047d684 = function(arg0) {
+exports.__wbg_isSafeInteger_d216eda7911dde36 = function(arg0) {
     const ret = Number.isSafeInteger(arg0);
     return ret;
 };
 
-module.exports.__wbg_iterator_4068add5b2aef7a6 = function() {
+exports.__wbg_iterator_e5822695327a3c39 = function() {
     const ret = Symbol.iterator;
     return ret;
 };
 
-module.exports.__wbg_length_ab6d22b5ead75c72 = function(arg0) {
+exports.__wbg_length_69bca3cb64fc8748 = function(arg0) {
     const ret = arg0.length;
     return ret;
 };
 
-module.exports.__wbg_length_f00ec12454a5d9fd = function(arg0) {
+exports.__wbg_length_cdd215e10d9dd507 = function(arg0) {
     const ret = arg0.length;
     return ret;
 };
 
-module.exports.__wbg_log_bff357b3df4db934 = function(arg0, arg1, arg2, arg3) {
+exports.__wbg_log_45eb3a49e7cdcb64 = function(arg0, arg1, arg2, arg3) {
     console.log(arg0, arg1, arg2, arg3);
 };
 
-module.exports.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
+exports.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
     const ret = arg0.msCrypto;
     return ret;
 };
 
-module.exports.__wbg_new_07b483f72211fd66 = function() {
+exports.__wbg_new_1acc0b6eea89d040 = function() {
     const ret = new Object();
     return ret;
 };
 
-module.exports.__wbg_new_186abcfdff244e42 = function() { return handleError(function () {
+exports.__wbg_new_2531773dac38ebb3 = function() { return handleError(function () {
     const ret = new AbortController();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_new_4796e1cd2eb9ea6d = function() { return handleError(function () {
-    const ret = new Headers();
-    return ret;
-}, arguments) };
-
-module.exports.__wbg_new_58353953ad2097cc = function() {
-    const ret = new Array();
-    return ret;
-};
-
-module.exports.__wbg_new_a979b4b45bd55c7f = function() {
-    const ret = new Map();
-    return ret;
-};
-
-module.exports.__wbg_new_e30c39c06edaabf2 = function(arg0, arg1) {
+exports.__wbg_new_3c3d849046688a66 = function(arg0, arg1) {
     try {
         var state0 = {a: arg0, b: arg1};
         var cb0 = (arg0, arg1) => {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_120(a, state0.b, arg0, arg1);
+                return wasm_bindgen__convert__closures_____invoke__h07d45d2c9c5e1bbe(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -2015,209 +2838,296 @@ module.exports.__wbg_new_e30c39c06edaabf2 = function(arg0, arg1) {
     }
 };
 
-module.exports.__wbg_new_e52b3efaaa774f96 = function(arg0) {
+exports.__wbg_new_5a79be3ab53b8aa5 = function(arg0) {
     const ret = new Uint8Array(arg0);
     return ret;
 };
 
-module.exports.__wbg_newfromslice_7c05ab1297cb2d88 = function(arg0, arg1) {
+exports.__wbg_new_68651c719dcda04e = function() {
+    const ret = new Map();
+    return ret;
+};
+
+exports.__wbg_new_9edf9838a2def39c = function() { return handleError(function () {
+    const ret = new Headers();
+    return ret;
+}, arguments) };
+
+exports.__wbg_new_a7442b4b19c1a356 = function(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+exports.__wbg_new_e17d9f43105b08be = function() {
+    const ret = new Array();
+    return ret;
+};
+
+exports.__wbg_new_from_slice_92f4d78ca282a2d2 = function(arg0, arg1) {
     const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
     return ret;
 };
 
-module.exports.__wbg_newnoargs_ff528e72d35de39a = function(arg0, arg1) {
+exports.__wbg_new_no_args_ee98eee5275000a4 = function(arg0, arg1) {
     const ret = new Function(getStringFromWasm0(arg0, arg1));
     return ret;
 };
 
-module.exports.__wbg_newwithbyteoffsetandlength_3b01ecda099177e8 = function(arg0, arg1, arg2) {
+exports.__wbg_new_with_byte_offset_and_length_46e3e6a5e9f9e89b = function(arg0, arg1, arg2) {
     const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
     return ret;
 };
 
-module.exports.__wbg_newwithlength_08f872dc1e3ada2e = function(arg0) {
+exports.__wbg_new_with_into_underlying_source_b47f6a6a596a7f24 = function(arg0, arg1) {
+    const ret = new ReadableStream(IntoUnderlyingSource.__wrap(arg0), arg1);
+    return ret;
+};
+
+exports.__wbg_new_with_length_01aa0dc35aa13543 = function(arg0) {
     const ret = new Uint8Array(arg0 >>> 0);
     return ret;
 };
 
-module.exports.__wbg_newwithstrandinit_f8a9dbe009d6be37 = function() { return handleError(function (arg0, arg1, arg2) {
-    const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
+exports.__wbg_new_with_opt_readable_stream_and_init_b3dac7204db32cac = function() { return handleError(function (arg0, arg1) {
+    const ret = new Response(arg0, arg1);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_next_8bb824d217961b5d = function(arg0) {
-    const ret = arg0.next;
+exports.__wbg_new_with_str_and_init_0ae7728b6ec367b1 = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
-};
+}, arguments) };
 
-module.exports.__wbg_next_e2da48d8fff7439a = function() { return handleError(function (arg0) {
+exports.__wbg_next_020810e0ae8ebcb0 = function() { return handleError(function (arg0) {
     const ret = arg0.next();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_node_905d3e251edff8a2 = function(arg0) {
+exports.__wbg_next_2c826fe5dfec6b6a = function(arg0) {
+    const ret = arg0.next;
+    return ret;
+};
+
+exports.__wbg_node_905d3e251edff8a2 = function(arg0) {
     const ret = arg0.node;
     return ret;
 };
 
-module.exports.__wbg_now_eb0821f3bd9f6529 = function() {
+exports.__wbg_now_2c95c9de01293173 = function(arg0) {
+    const ret = arg0.now();
+    return ret;
+};
+
+exports.__wbg_now_793306c526e2e3b6 = function() {
     const ret = Date.now();
     return ret;
 };
 
-module.exports.__wbg_parse_c7ba327fb6231e7f = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_parse_2a704d6b78abb2b8 = function() { return handleError(function (arg0, arg1) {
     const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
     return ret;
 }, arguments) };
 
-module.exports.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
-    const ret = arg0.process;
+exports.__wbg_performance_7a3ffd0b17f663ad = function(arg0) {
+    const ret = arg0.performance;
     return ret;
 };
 
-module.exports.__wbg_push_73fd7b5550ebf707 = function(arg0, arg1) {
-    const ret = arg0.push(arg1);
+exports.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
+    const ret = arg0.process;
     return ret;
 };
 
-module.exports.__wbg_queueMicrotask_46c1df247678729f = function(arg0) {
-    queueMicrotask(arg0);
+exports.__wbg_prototypesetcall_2a6620b6922694b2 = function(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+};
+
+exports.__wbg_publickey_new = function(arg0) {
+    const ret = PublicKey.__wrap(arg0);
+    return ret;
 };
 
-module.exports.__wbg_queueMicrotask_8acf3ccb75ed8d11 = function(arg0) {
+exports.__wbg_queueMicrotask_34d692c25c47d05b = function(arg0) {
     const ret = arg0.queueMicrotask;
     return ret;
 };
 
-module.exports.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_queueMicrotask_9d76cacb20c84d58 = function(arg0) {
+    queueMicrotask(arg0);
+};
+
+exports.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
     arg0.randomFillSync(arg1);
 }, arguments) };
 
-module.exports.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {
+exports.__wbg_read_48f1593df542f968 = function(arg0) {
+    const ret = arg0.read();
+    return ret;
+};
+
+exports.__wbg_releaseLock_5d0b5a68887b891d = function(arg0) {
+    arg0.releaseLock();
+};
+
+exports.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {
     const ret = module.require;
     return ret;
 }, arguments) };
 
-module.exports.__wbg_resolve_0dac8c580ffd4678 = function(arg0) {
+exports.__wbg_resolve_caf97c30b83f7053 = function(arg0) {
     const ret = Promise.resolve(arg0);
     return ret;
 };
 
-module.exports.__wbg_session_new = function(arg0) {
+exports.__wbg_respond_0f4dbf5386f5c73e = function() { return handleError(function (arg0, arg1) {
+    arg0.respond(arg1 >>> 0);
+}, arguments) };
+
+exports.__wbg_session_new = function(arg0) {
     const ret = Session.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_setTimeout_2b339866a2aa3789 = function(arg0, arg1) {
+exports.__wbg_setTimeout_7bb3429662ab1e70 = function(arg0, arg1) {
     const ret = setTimeout(arg0, arg1);
     return ret;
 };
 
-module.exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
     arg0[arg1] = arg2;
 };
 
-module.exports.__wbg_set_7422acbe992d64ab = function(arg0, arg1, arg2) {
-    arg0[arg1 >>> 0] = arg2;
-};
-
-module.exports.__wbg_set_b042eef31c50834d = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+exports.__wbg_set_8b342d8cd9d2a02c = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments) };
 
-module.exports.__wbg_set_d6bdfd275fb8a4ce = function(arg0, arg1, arg2) {
+exports.__wbg_set_907fb406c34a251d = function(arg0, arg1, arg2) {
     const ret = arg0.set(arg1, arg2);
     return ret;
 };
 
-module.exports.__wbg_set_fe4e79d1ed3b0e9b = function(arg0, arg1, arg2) {
-    arg0.set(arg1, arg2 >>> 0);
+exports.__wbg_set_9e6516df7b7d0f19 = function(arg0, arg1, arg2) {
+    arg0.set(getArrayU8FromWasm0(arg1, arg2));
 };
 
-module.exports.__wbg_setbody_971ec015fc13d6b4 = function(arg0, arg1) {
+exports.__wbg_set_body_3c365989753d61f4 = function(arg0, arg1) {
     arg0.body = arg1;
 };
 
-module.exports.__wbg_setcache_a94cd14dc0cc72a2 = function(arg0, arg1) {
+exports.__wbg_set_c213c871859d6500 = function(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+};
+
+exports.__wbg_set_c2abbebe8b9ebee1 = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(arg0, arg1, arg2);
+    return ret;
+}, arguments) };
+
+exports.__wbg_set_cache_2f9deb19b92b81e3 = function(arg0, arg1) {
     arg0.cache = __wbindgen_enum_RequestCache[arg1];
 };
 
-module.exports.__wbg_setcredentials_920d91fb5984c94a = function(arg0, arg1) {
+exports.__wbg_set_credentials_f621cd2d85c0c228 = function(arg0, arg1) {
     arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
 };
 
-module.exports.__wbg_setheaders_65a4eb4c0443ae61 = function(arg0, arg1) {
+exports.__wbg_set_headers_107379072e02fee5 = function(arg0, arg1) {
+    arg0.headers = arg1;
+};
+
+exports.__wbg_set_headers_6926da238cd32ee4 = function(arg0, arg1) {
     arg0.headers = arg1;
 };
 
-module.exports.__wbg_setmethod_8ce1be0b4d701b7c = function(arg0, arg1, arg2) {
+exports.__wbg_set_high_water_mark_5142ac1d2fb46365 = function(arg0, arg1) {
+    arg0.highWaterMark = arg1;
+};
+
+exports.__wbg_set_method_c02d8cbbe204ac2d = function(arg0, arg1, arg2) {
     arg0.method = getStringFromWasm0(arg1, arg2);
 };
 
-module.exports.__wbg_setmode_bd35f026f55b6247 = function(arg0, arg1) {
+exports.__wbg_set_mode_52ef73cfa79639cb = function(arg0, arg1) {
     arg0.mode = __wbindgen_enum_RequestMode[arg1];
 };
 
-module.exports.__wbg_setsignal_8e72abfe7ee03c97 = function(arg0, arg1) {
+exports.__wbg_set_name_d94846a29e626702 = function(arg0, arg1, arg2) {
+    arg0.name = getStringFromWasm0(arg1, arg2);
+};
+
+exports.__wbg_set_signal_dda2cf7ccb6bee0f = function(arg0, arg1) {
     arg0.signal = arg1;
 };
 
-module.exports.__wbg_signal_b96223519a041faa = function(arg0) {
+exports.__wbg_set_status_886bf143c25d0706 = function(arg0, arg1) {
+    arg0.status = arg1;
+};
+
+exports.__wbg_set_status_text_3d83b7e559c076b2 = function(arg0, arg1, arg2) {
+    arg0.statusText = getStringFromWasm0(arg1, arg2);
+};
+
+exports.__wbg_signal_4db5aa055bf9eb9a = function(arg0) {
     const ret = arg0.signal;
     return ret;
 };
 
-module.exports.__wbg_static_accessor_GLOBAL_487c52c58d65314d = function() {
+exports.__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e = function() {
     const ret = typeof global === 'undefined' ? null : global;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_static_accessor_GLOBAL_THIS_ee9704f328b6b291 = function() {
+exports.__wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac = function() {
     const ret = typeof globalThis === 'undefined' ? null : globalThis;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_static_accessor_SELF_78c9e3071b912620 = function() {
+exports.__wbg_static_accessor_SELF_6fdf4b64710cc91b = function() {
     const ret = typeof self === 'undefined' ? null : self;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_static_accessor_WINDOW_a093d21393777366 = function() {
+exports.__wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2 = function() {
     const ret = typeof window === 'undefined' ? null : window;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_status_a54682bbe52f9058 = function(arg0) {
+exports.__wbg_status_de7eed5a7a5bfd5d = function(arg0) {
     const ret = arg0.status;
     return ret;
 };
 
-module.exports.__wbg_stringify_c242842b97f054cc = function() { return handleError(function (arg0) {
+exports.__wbg_stringify_b5fb28f6465d9c3e = function() { return handleError(function (arg0) {
     const ret = JSON.stringify(arg0);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_subarray_dd4ade7d53bd8e26 = function(arg0, arg1, arg2) {
+exports.__wbg_subarray_480600f3d6a9f26c = function(arg0, arg1, arg2) {
     const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
     return ret;
 };
 
-module.exports.__wbg_text_ec0e22f60e30dd2f = function() { return handleError(function (arg0) {
+exports.__wbg_text_dc33c15c17bdfb52 = function() { return handleError(function (arg0) {
     const ret = arg0.text();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_then_82ab9fb4080f1707 = function(arg0, arg1, arg2) {
+exports.__wbg_then_4f46f6544e6b4a28 = function(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+};
+
+exports.__wbg_then_70d05cf780a18d77 = function(arg0, arg1, arg2) {
     const ret = arg0.then(arg1, arg2);
     return ret;
 };
 
-module.exports.__wbg_then_db882932c0c714c6 = function(arg0, arg1) {
-    const ret = arg0.then(arg1);
+exports.__wbg_toString_8eec07f6f4c057e4 = function(arg0) {
+    const ret = arg0.toString();
     return ret;
 };
 
-module.exports.__wbg_url_e6ed869ea05b7a71 = function(arg0, arg1) {
+exports.__wbg_url_b36d2a5008eb056f = function(arg0, arg1) {
     const ret = arg1.url;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -2225,87 +3135,77 @@ module.exports.__wbg_url_e6ed869ea05b7a71 = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-module.exports.__wbg_value_17b896954e14f896 = function(arg0) {
+exports.__wbg_value_692627309814bb8c = function(arg0) {
     const ret = arg0.value;
     return ret;
 };
 
-module.exports.__wbg_versions_c01dfd4722a88165 = function(arg0) {
+exports.__wbg_versions_c01dfd4722a88165 = function(arg0) {
     const ret = arg0.versions;
     return ret;
 };
 
-module.exports.__wbg_warn_90607373221a6b1c = function(arg0, arg1, arg2, arg3) {
-    console.warn(arg0, arg1, arg2, arg3);
-};
-
-module.exports.__wbindgen_array_new = function() {
-    const ret = [];
-    return ret;
+exports.__wbg_view_f6c15ac9fed63bbd = function(arg0) {
+    const ret = arg0.view;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbindgen_array_push = function(arg0, arg1) {
-    arg0.push(arg1);
+exports.__wbg_warn_8f5b5437666d0885 = function(arg0, arg1, arg2, arg3) {
+    console.warn(arg0, arg1, arg2, arg3);
 };
 
-module.exports.__wbindgen_bigint_from_i64 = function(arg0) {
-    const ret = arg0;
+exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 };
 
-module.exports.__wbindgen_bigint_from_u64 = function(arg0) {
-    const ret = BigInt.asUintN(64, arg0);
+exports.__wbindgen_cast_236fa6323a6eeed0 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 175, function: Function { arguments: [], shim_idx: 176, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h762d1c23bf8139ea, wasm_bindgen__convert__closures_____invoke__h13019d5ee70bd6b6);
     return ret;
 };
 
-module.exports.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
-    const v = arg1;
-    const ret = typeof(v) === 'bigint' ? v : undefined;
-    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-};
-
-module.exports.__wbindgen_boolean_get = function(arg0) {
-    const v = arg0;
-    const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+exports.__wbindgen_cast_25a0a844437d0e92 = function(arg0, arg1) {
+    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+    // Cast intrinsic for `Vector(NamedExternref("string")) -> Externref`.
+    const ret = v0;
     return ret;
 };
 
-module.exports.__wbindgen_cb_drop = function(arg0) {
-    const obj = arg0.original;
-    if (obj.cnt-- == 1) {
-        obj.a = 0;
-        return true;
-    }
-    const ret = false;
+exports.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper2747 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 154, __wbg_adapter_54);
+exports.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper3056 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 154, __wbg_adapter_57);
+exports.__wbindgen_cast_c389e99dd7b90da6 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 175, function: Function { arguments: [Externref], shim_idx: 193, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h762d1c23bf8139ea, wasm_bindgen__convert__closures_____invoke__h69202035a90512ea);
     return ret;
 };
 
-module.exports.__wbindgen_debug_string = function(arg0, arg1) {
-    const ret = debugString(arg1);
-    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+exports.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return ret;
 };
 
-module.exports.__wbindgen_in = function(arg0, arg1) {
-    const ret = arg0 in arg1;
+exports.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
     return ret;
 };
 
-module.exports.__wbindgen_init_externref_table = function() {
-    const table = wasm.__wbindgen_export_4;
+exports.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_externrefs;
     const offset = table.grow(4);
     table.set(0, undefined);
     table.set(offset + 0, undefined);
@@ -2315,89 +3215,10 @@ module.exports.__wbindgen_init_externref_table = function() {
     ;
 };
 
-module.exports.__wbindgen_is_bigint = function(arg0) {
-    const ret = typeof(arg0) === 'bigint';
-    return ret;
-};
-
-module.exports.__wbindgen_is_function = function(arg0) {
-    const ret = typeof(arg0) === 'function';
-    return ret;
-};
-
-module.exports.__wbindgen_is_null = function(arg0) {
-    const ret = arg0 === null;
-    return ret;
-};
-
-module.exports.__wbindgen_is_object = function(arg0) {
-    const val = arg0;
-    const ret = typeof(val) === 'object' && val !== null;
-    return ret;
-};
-
-module.exports.__wbindgen_is_string = function(arg0) {
-    const ret = typeof(arg0) === 'string';
-    return ret;
-};
-
-module.exports.__wbindgen_is_undefined = function(arg0) {
-    const ret = arg0 === undefined;
-    return ret;
-};
-
-module.exports.__wbindgen_jsval_eq = function(arg0, arg1) {
-    const ret = arg0 === arg1;
-    return ret;
-};
-
-module.exports.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
-    const ret = arg0 == arg1;
-    return ret;
-};
-
-module.exports.__wbindgen_memory = function() {
-    const ret = wasm.memory;
-    return ret;
-};
-
-module.exports.__wbindgen_number_get = function(arg0, arg1) {
-    const obj = arg1;
-    const ret = typeof(obj) === 'number' ? obj : undefined;
-    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-};
-
-module.exports.__wbindgen_number_new = function(arg0) {
-    const ret = arg0;
-    return ret;
-};
-
-module.exports.__wbindgen_string_get = function(arg0, arg1) {
-    const obj = arg1;
-    const ret = typeof(obj) === 'string' ? obj : undefined;
-    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-};
-
-module.exports.__wbindgen_string_new = function(arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
-};
-
-module.exports.__wbindgen_throw = function(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-};
-
-const path = require('path').join(__dirname, 'pubky_bg.wasm');
-const bytes = require('fs').readFileSync(path);
-
-const wasmModule = new WebAssembly.Module(bytes);
-const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
-wasm = wasmInstance.exports;
-module.exports.__wasm = wasm;
+const wasmPath = `${__dirname}/pubky_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+const wasm = exports.__wasm = new WebAssembly.Instance(wasmModule, imports).exports;
 
 wasm.__wbindgen_start();