@synonymdev/pubky 0.6.0 → 0.7.0

package/index.cjs

@@ -3,362 +3,8 @@ const makeFetchCookie = require("fetch-cookie").default;
 let originalFetch = globalThis.fetch;
 globalThis.fetch = makeFetchCookie(originalFetch);
 
+/* @ts-self-types="./pubky.d.ts" */
 
-let imports = {};
-imports['__wbindgen_placeholder__'] = module.exports;
-
-let cachedUint8ArrayMemory0 = null;
-
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-function decodeText(ptr, len) {
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
-}
-
-let WASM_VECTOR_LEN = 0;
-
-const cachedTextEncoder = new TextEncoder();
-
-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 passStringToWasm0(arg, malloc, realloc) {
-
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-let cachedDataViewMemory0 = null;
-
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
-    }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches && builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    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}`);
-    }
-}
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-/**
- * Set the global logging verbosity for the WASM Pubky SDK. Routes Rust `log` output to the browser console.
- *
- * 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 {Level} level
- *        Minimum log level to enable. One of: "error" | "warn" | "info" | "debug" | "trace".
- *
- * @returns {void}
- *
- * @throws {Error}
- *         If `level` is invalid ("Invalid log level") or the logger cannot be initialized
- *         (e.g., already initialized).
- *
- * Usage:
- *   Call once at application startup, before invoking other SDK APIs.
- * @param {Level} level
- */
-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.
- *
- * - Normalizes action order (`wr` -> `rw`)
- * - Throws `InvalidInput` listing malformed entries.
- *
- * @param {string} input
- * @returns {string} Normalized string (same shape as input).
- * @throws {PubkyError} `{ name: "InvalidInput" }` with a helpful message.
- * The error's `data` field is `{ invalidEntries: string[] }` listing malformed tokens.
- * @param {string} input
- * @returns {string}
- */
-exports.validateCapabilities = function(input) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.validateCapabilities(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);
-    }
-};
-
-function wasm_bindgen__convert__closures_____invoke__h13019d5ee70bd6b6(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h13019d5ee70bd6b6(arg0, arg1);
-}
-
-function wasm_bindgen__convert__closures_____invoke__h69202035a90512ea(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h69202035a90512ea(arg0, arg1, arg2);
-}
-
-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"];
-
-const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
-
-const AuthFlowFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_authflow_free(ptr >>> 0, 1));
 /**
  * Start and control a pubkyauth authorization flow.
  *
@@ -368,7 +14,6 @@ const AuthFlowFinalization = (typeof FinalizationRegistry === 'undefined')
  * 3) `awaitApproval()` to receive a ready `Session`
  */
 class AuthFlow {
-
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(AuthFlow.prototype);
@@ -376,68 +21,16 @@ class AuthFlow {
         AuthFlowFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         AuthFlowFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_authflow_free(ptr, 0);
     }
-    /**
-     * Start a flow (standalone).
-     * 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.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.
-     *
-     * @returns {AuthFlow}
-     * A running auth flow. Call `authorizationUrl()` to show the deep link,
-     * then `awaitApproval()` to receive a `Session`.
-     * @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-cool-app/:rw,/pub/pubky.app/:w");
-     * renderQRCode(flow.authorizationUrl());
-     * const session = await flow.awaitApproval();
-     * @param {Capabilities} capabilities
-     * @param {AuthFlowKind} kind
-     * @param {string | null} [relay]
-     * @returns {AuthFlow}
-     */
-    static start(capabilities, kind, relay) {
-        const ptr0 = passStringToWasm0(capabilities, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        _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]);
-        }
-        return AuthFlow.__wrap(ret[0]);
-    }
     /**
      * Return the authorization deep link (URL) to show as QR or open on the signer device.
      *
@@ -488,6 +81,56 @@ class AuthFlow {
         const ret = wasm.authflow_awaitToken(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Start a flow (standalone).
+     * 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.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/inbox/"`.
+     * Defaults to the default Synonym-hosted relay when omitted.
+     *
+     * @returns {AuthFlow}
+     * A running auth flow. Call `authorizationUrl()` to show the deep link,
+     * then `awaitApproval()` to receive a `Session`.
+     * @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-cool-app/:rw,/pub/pubky.app/:w");
+     * renderQRCode(flow.authorizationUrl());
+     * const session = await flow.awaitApproval();
+     * @param {Capabilities} capabilities
+     * @param {AuthFlowKind} kind
+     * @param {string | null} [relay]
+     * @returns {AuthFlow}
+     */
+    static start(capabilities, kind, relay) {
+        const ptr0 = passStringToWasm0(capabilities, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _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]);
+        }
+        return AuthFlow.__wrap(ret[0]);
+    }
     /**
      * Non-blocking single poll step (advanced UIs).
      *
@@ -500,18 +143,13 @@ class 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);
@@ -519,18 +157,35 @@ class AuthFlowKind {
         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);
     }
+    /**
+     * 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);
+        }
+    }
     /**
      * Create a sign in flow.
      * @returns {AuthFlowKind}
@@ -555,33 +210,10 @@ class AuthFlowKind {
         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: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_authtoken_free(ptr >>> 0, 1));
 /**
  * AuthToken: signed, time-bound proof of key ownership.
  *
@@ -609,7 +241,6 @@ const AuthTokenFinalization = (typeof FinalizationRegistry === 'undefined')
  * `Uint8Array`, and [`AuthToken.verify()`] to parse + verify on the server.
  */
 class AuthToken {
-
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(AuthToken.prototype);
@@ -617,44 +248,32 @@ class AuthToken {
         AuthTokenFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         AuthTokenFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_authtoken_free(ptr, 0);
     }
     /**
-     * Parse and verify an `AuthToken` from its canonical bytes.
-     *
-     * - Verifies version, timestamp freshness window, and signature.
-     * - Throws on invalid/expired/unknown version.
+     * Returns the **capabilities** requested by the flow at the time this token was signed.
      *
-     * Use this on your server after receiving `Uint8Array` from the client.
+     * Most auth-only flows pass an empty string to `startAuthFlow("", relay)`, so this will
+     * commonly be an empty array.
      *
-     * ```js
-     * import { AuthToken } from "@synonymdev/pubky";
+     * Returns: `string[]`, where each item is the canonical entry `"<scope>:<actions>"`.
      *
-     * export async function POST(req) {
-     *   const bytes = new Uint8Array(await req.arrayBuffer());
-     *   const token = AuthToken.verify(bytes); // throws on failure
-     *   return new Response(token.publicKey().toString(), { status: 200 });
-     * }
-     * ```
-     * @param {Uint8Array} bytes
-     * @returns {AuthToken}
+     * Example entry: `"/pub/my-cool-app/:rw"`
+     * @returns {string[]}
      */
-    static verify(bytes) {
-        const ret = wasm.authtoken_verify(bytes);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return AuthToken.__wrap(ret[0]);
+    get capabilities() {
+        const ret = wasm.authtoken_capabilities(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
      * Deserialize an `AuthToken` **without** verification.
@@ -687,23 +306,6 @@ class AuthToken {
         const ret = wasm.authtoken_publicKey(this.__wbg_ptr);
         return PublicKey.__wrap(ret);
     }
-    /**
-     * Returns the **capabilities** requested by the flow at the time this token was signed.
-     *
-     * Most auth-only flows pass an empty string to `startAuthFlow("", relay)`, so this will
-     * commonly be an empty array.
-     *
-     * Returns: `string[]`, where each item is the canonical entry `"<scope>:<actions>"`.
-     *
-     * Example entry: `"/pub/my-cool-app/:rw"`
-     * @returns {string[]}
-     */
-    get capabilities() {
-        const ret = wasm.authtoken_capabilities(this.__wbg_ptr);
-        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.
      *
@@ -719,14 +321,37 @@ class AuthToken {
         const ret = wasm.authtoken_toBytes(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Parse and verify an `AuthToken` from its canonical bytes.
+     *
+     * - Verifies version, timestamp freshness window, and signature.
+     * - Throws on invalid/expired/unknown version.
+     *
+     * Use this on your server after receiving `Uint8Array` from the client.
+     *
+     * ```js
+     * import { AuthToken } from "@synonymdev/pubky";
+     *
+     * export async function POST(req) {
+     *   const bytes = new Uint8Array(await req.arrayBuffer());
+     *   const token = AuthToken.verify(bytes); // throws on failure
+     *   return new Response(token.publicKey().toString(), { status: 200 });
+     * }
+     * ```
+     * @param {Uint8Array} bytes
+     * @returns {AuthToken}
+     */
+    static verify(bytes) {
+        const ret = wasm.authtoken_verify(bytes);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AuthToken.__wrap(ret[0]);
+    }
 }
 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 facade and actors.
  *
@@ -734,7 +359,6 @@ const ClientFinalization = (typeof FinalizationRegistry === 'undefined')
  * - In browsers/undici, passes `credentials: "include"` to send cookies.
  */
 class Client {
-
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(Client.prototype);
@@ -742,14 +366,12 @@ class Client {
         ClientFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         ClientFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_client_free(ptr, 0);
@@ -835,32 +457,302 @@ class Client {
     }
 }
 if (Symbol.dispose) Client.prototype[Symbol.dispose] = Client.prototype.free;
-
 exports.Client = Client;
 
-const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
-
-class IntoUnderlyingByteSource {
-
+/**
+ * A single event from the event stream.
+ *
+ * @example
+ * ```typescript
+ * for await (const event of stream) {
+ *   console.log(event.eventType);  // "PUT" or "DEL"
+ *   console.log(event.cursor);     // cursor string for pagination
+ *
+ *   if (event.eventType === "PUT") {
+ *     console.log("Hash:", event.contentHash);
+ *   }
+ *
+ *   // Access resource details
+ *   console.log(event.resource.owner.z32()); // User's public key
+ *   console.log(event.resource.path);        // "/pub/example.txt"
+ *   console.log(event.resource.toPubkyUrl()); // Full pubky:// URL
+ * }
+ * ```
+ */
+class Event {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Event.prototype);
+        obj.__wbg_ptr = ptr;
+        EventFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        IntoUnderlyingByteSourceFinalization.unregister(this);
+        EventFinalization.unregister(this);
         return ptr;
     }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_event_free(ptr, 0);
+    }
+    /**
+     * Get the content hash (only for PUT events).
+     * Returns the blake3 hash in base64 format, or undefined for DELETE events.
+     * @returns {string | undefined}
+     */
+    get contentHash() {
+        const ret = wasm.event_contentHash(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;
+    }
+    /**
+     * Get the cursor for pagination.
+     * @returns {string}
+     */
+    get cursor() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.event_cursor(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);
+        }
+    }
+    /**
+     * Get the event type ("PUT" or "DEL").
+     * @returns {string}
+     */
+    get eventType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.event_eventType(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);
+        }
+    }
+    /**
+     * Get the resource that was created, updated, or deleted.
+     * @returns {PubkyResource}
+     */
+    get resource() {
+        const ret = wasm.event_resource(this.__wbg_ptr);
+        return PubkyResource.__wrap(ret);
+    }
+}
+if (Symbol.dispose) Event.prototype[Symbol.dispose] = Event.prototype.free;
+exports.Event = Event;
 
+/**
+ * Builder for creating an event stream subscription.
+ *
+ * Construct via `Pubky.eventStreamForUser()` or `Pubky.eventStreamFor()`.
+ *
+ * @example
+ * ```typescript
+ * const stream = await pubky.eventStreamForUser(userPubkey, null)
+ *   .live()
+ *   .limit(100)
+ *   .path("/pub/")
+ *   .subscribe();
+ *
+ * for await (const event of stream) {
+ *   console.log(event.eventType, event.resource.path);
+ * }
+ * ```
+ */
+class EventStreamBuilder {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(EventStreamBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        EventStreamBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EventStreamBuilderFinalization.unregister(this);
+        return ptr;
+    }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
+        wasm.__wbg_eventstreambuilder_free(ptr, 0);
     }
     /**
-     * @returns {ReadableStreamType}
+     * Add multiple users to the event stream subscription at once.
+     *
+     * Each user can have an independent cursor position. If a user already exists,
+     * their cursor value is overwritten.
+     *
+     * @param {Array<[string, string | null]>} users - Array of [z32PublicKey, cursor] tuples
+     * @returns {EventStreamBuilder} - Builder for chaining
+     * @throws {Error} - If total users would exceed 50 or if any cursor/pubkey is invalid
+     *
+     * @example
+     * ```typescript
+     * const users: [string, string | null][] = [
+     *   [user1.z32(), null],
+     *   [user2.z32(), "100"],
+     * ];
+     * const stream = await pubky.eventStreamFor(homeserver)
+     *   .addUsers(users)
+     *   .live()
+     *   .subscribe();
+     * ```
+     * @param {Array<any>} users
+     * @returns {EventStreamBuilder}
      */
-    get type() {
-        const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
-        return __wbindgen_enum_ReadableStreamType[ret];
+    addUsers(users) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.eventstreambuilder_addUsers(ptr, users);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return EventStreamBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Set maximum number of events to receive before closing the connection.
+     *
+     * If omitted:
+     * - With `live=false`: sends all historical events, then closes
+     * - With `live=true`: sends all historical events, then enters live mode (infinite stream)
+     *
+     * @param {number} limit - Maximum number of events (1-65535)
+     * @returns {EventStreamBuilder} - Builder for chaining
+     * @param {number} limit
+     * @returns {EventStreamBuilder}
+     */
+    limit(limit) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.eventstreambuilder_limit(ptr, limit);
+        return EventStreamBuilder.__wrap(ret);
+    }
+    /**
+     * Enable live streaming mode.
+     *
+     * When called, the stream will:
+     * 1. First deliver all historical events (oldest first)
+     * 2. Then remain open to stream new events as they occur in real-time
+     *
+     * Without this flag (default): Stream only delivers historical events and closes.
+     *
+     * **Note**: Cannot be combined with `reverse()`.
+     *
+     * ## Cleanup
+     * To stop a live stream, use the reader's `cancel()` method:
+     * ```typescript
+     * const stream = await pubky.eventStreamForUser(user, null).live().subscribe();
+     * const reader = stream.getReader();
+     *
+     * while (true) {
+     *   const { done, value } = await reader.read();
+     *   if (shouldStop) {
+     *     await reader.cancel(); // Closes the connection
+     *     break;
+     *   }
+     * }
+     * ```
+     *
+     * @returns {EventStreamBuilder} - Builder for chaining
+     * @returns {EventStreamBuilder}
+     */
+    live() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.eventstreambuilder_live(ptr);
+        return EventStreamBuilder.__wrap(ret);
+    }
+    /**
+     * Filter events by path prefix.
+     *
+     * Format: Path WITHOUT `pubky://` scheme or user pubkey (e.g., "/pub/files/" or "/pub/").
+     * Only events whose path starts with this prefix are returned.
+     *
+     * @param {string} path - Path prefix to filter by
+     * @returns {EventStreamBuilder} - Builder for chaining
+     * @param {string} path
+     * @returns {EventStreamBuilder}
+     */
+    path(path) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.eventstreambuilder_path(ptr, ptr0, len0);
+        return EventStreamBuilder.__wrap(ret);
+    }
+    /**
+     * Return events in reverse chronological order (newest first).
+     *
+     * When called, events are delivered from newest to oldest, then the stream closes.
+     *
+     * Without this flag (default): Events are delivered oldest first.
+     *
+     * **Note**: Cannot be combined with `live()`.
+     *
+     * @returns {EventStreamBuilder} - Builder for chaining
+     * @returns {EventStreamBuilder}
+     */
+    reverse() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.eventstreambuilder_reverse(ptr);
+        return EventStreamBuilder.__wrap(ret);
+    }
+    /**
+     * Subscribe to the event stream.
+     *
+     * This performs the following steps:
+     * 1. Resolves the user's homeserver via DHT/PKDNS
+     * 2. Constructs the `/events-stream` URL with query parameters
+     * 3. Makes the HTTP request
+     * 4. Returns a Web ReadableStream of parsed events
+     *
+     * @returns {Promise<ReadableStream>} - A Web ReadableStream that yields Event objects
+     *
+     * @throws {PubkyError}
+     * - `{ name: "RequestError" }` if the homeserver cannot be resolved
+     * - `{ name: "ValidationError" }` if `live=true` and `reverse=true` (invalid combination)
+     * - Propagates HTTP request errors
+     *
+     * @example
+     * ```typescript
+     * const stream = await builder.subscribe();
+     * for await (const event of stream) {
+     *   console.log(`${event.eventType}: ${event.resource.path}`);
+     * }
+     * ```
+     * @returns {Promise<ReadableStream>}
+     */
+    subscribe() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.eventstreambuilder_subscribe(ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) EventStreamBuilder.prototype[Symbol.dispose] = EventStreamBuilder.prototype.free;
+exports.EventStreamBuilder = EventStreamBuilder;
+
+class IntoUnderlyingByteSource {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntoUnderlyingByteSourceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
     }
     /**
      * @returns {number}
@@ -869,11 +761,9 @@ class IntoUnderlyingByteSource {
         const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
         return ret >>> 0;
     }
-    /**
-     * @param {ReadableByteStreamController} controller
-     */
-    start(controller) {
-        wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
+    cancel() {
+        const ptr = this.__destroy_into_raw();
+        wasm.intounderlyingbytesource_cancel(ptr);
     }
     /**
      * @param {ReadableByteStreamController} controller
@@ -883,38 +773,41 @@ class IntoUnderlyingByteSource {
         const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
         return ret;
     }
-    cancel() {
-        const ptr = this.__destroy_into_raw();
-        wasm.intounderlyingbytesource_cancel(ptr);
+    /**
+     * @param {ReadableByteStreamController} controller
+     */
+    start(controller) {
+        wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
+    }
+    /**
+     * @returns {ReadableStreamType}
+     */
+    get type() {
+        const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
+        return __wbindgen_enum_ReadableStreamType[ret];
     }
 }
 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);
     }
     /**
-     * @param {any} chunk
+     * @param {any} reason
      * @returns {Promise<any>}
      */
-    write(chunk) {
-        const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
+    abort(reason) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.intounderlyingsink_abort(ptr, reason);
         return ret;
     }
     /**
@@ -926,25 +819,18 @@ class IntoUnderlyingSink {
         return ret;
     }
     /**
-     * @param {any} reason
+     * @param {any} chunk
      * @returns {Promise<any>}
      */
-    abort(reason) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.intounderlyingsink_abort(ptr, reason);
+    write(chunk) {
+        const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
         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);
@@ -952,18 +838,20 @@ class IntoUnderlyingSource {
         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);
     }
+    cancel() {
+        const ptr = this.__destroy_into_raw();
+        wasm.intounderlyingsource_cancel(ptr);
+    }
     /**
      * @param {ReadableStreamDefaultController} controller
      * @returns {Promise<any>}
@@ -972,21 +860,11 @@ class IntoUnderlyingSource {
         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);
@@ -994,25 +872,43 @@ class Keypair {
         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]
+     * 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;
+    }
+    /**
+     * Decrypt a recovery file and return a Keypair (decrypted with the given passphrase).
+     * @param {Uint8Array} recovery_file
+     * @param {string} passphrase
      * @returns {Keypair}
      */
-    static random() {
-        const ret = wasm.keypair_random();
-        return Keypair.__wrap(ret);
+    static fromRecoveryFile(recovery_file, passphrase) {
+        const ptr0 = passArray8ToWasm0(recovery_file, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.keypair_fromRecoveryFile(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Keypair.__wrap(ret[0]);
     }
     /**
      * Generate a [Keypair] from a 32-byte secret.
@@ -1028,14 +924,6 @@ class Keypair {
         }
         return Keypair.__wrap(ret[0]);
     }
-    /**
-     * Returns the secret of this keypair.
-     * @returns {Uint8Array}
-     */
-    secret() {
-        const ret = wasm.keypair_secret(this.__wbg_ptr);
-        return ret;
-    }
     /**
      * Returns the [PublicKey] of this keypair.
      *
@@ -1052,46 +940,29 @@ class Keypair {
         return PublicKey.__wrap(ret);
     }
     /**
-     * Create a recovery file for this keypair (encrypted with the given passphrase).
-     * @param {string} passphrase
-     * @returns {Uint8Array}
+     * Generate a random [Keypair]
+     * @returns {Keypair}
      */
-    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;
+    static random() {
+        const ret = wasm.keypair_random();
+        return Keypair.__wrap(ret);
     }
     /**
-     * Decrypt a recovery file and return a Keypair (decrypted with the given passphrase).
-     * @param {Uint8Array} recovery_file
-     * @param {string} passphrase
-     * @returns {Keypair}
+     * Returns the secret of this keypair.
+     * @returns {Uint8Array}
      */
-    static fromRecoveryFile(recovery_file, passphrase) {
-        const ptr0 = passArray8ToWasm0(recovery_file, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.keypair_fromRecoveryFile(ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Keypair.__wrap(ret[0]);
+    secret() {
+        const ret = wasm.keypair_secret(this.__wbg_ptr);
+        return ret;
     }
 }
 if (Symbol.dispose) Keypair.prototype[Symbol.dispose] = Keypair.prototype.free;
-
 exports.Keypair = Keypair;
 
-const PkdnsFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_pkdns_free(ptr >>> 0, 1));
 /**
  * Resolve/publish `_pubky` PKDNS records (homeserver pointers).
  */
 class Pkdns {
-
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(Pkdns.prototype);
@@ -1099,30 +970,16 @@ class Pkdns {
         PkdnsFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         PkdnsFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_pkdns_free(ptr, 0);
     }
-    /**
-     * Read-only PKDNS actor (no keypair; resolve only).
-     */
-    constructor() {
-        const ret = wasm.pkdns_new();
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        PkdnsFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
     /**
      * PKDNS actor with publishing enabled (requires a keypair).
      * @param {Keypair} keypair
@@ -1136,6 +993,16 @@ class Pkdns {
         }
         return Pkdns.__wrap(ret[0]);
     }
+    /**
+     * Resolve the homeserver for **this** user (requires keypair).
+     *
+     * @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;
+    }
     /**
      * Resolve the homeserver for a given public key (read-only).
      *
@@ -1150,14 +1017,16 @@ class Pkdns {
         return ret;
     }
     /**
-     * Resolve the homeserver for **this** user (requires keypair).
-     *
-     * @returns {Promise<PublicKey|undefined>} Homeserver public key or `undefined` if not found.
-     * @returns {Promise<PublicKey | undefined>}
+     * Read-only PKDNS actor (no keypair; resolve only).
      */
-    getHomeserver() {
-        const ret = wasm.pkdns_getHomeserver(this.__wbg_ptr);
-        return ret;
+    constructor() {
+        const ret = wasm.pkdns_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        PkdnsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
      * Force publish homeserver immediately (even if fresh).
@@ -1199,17 +1068,12 @@ class Pkdns {
     }
 }
 if (Symbol.dispose) Pkdns.prototype[Symbol.dispose] = Pkdns.prototype.free;
-
 exports.Pkdns = Pkdns;
 
-const PubkyFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_pubky_free(ptr >>> 0, 1));
 /**
  * High-level entrypoint to the Pubky SDK.
  */
 class Pubky {
-
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(Pubky.prototype);
@@ -1217,18 +1081,109 @@ class Pubky {
         PubkyFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         PubkyFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_pubky_free(ptr, 0);
     }
+    /**
+     * Access the underlying HTTP client (advanced).
+     *
+     * @returns {Client}
+     * Use this for low-level `fetch()` calls or testing with raw URLs.
+     *
+     * @example
+     * const r = await pubky.client.fetch(`pubky://${userPk.z32()}/pub/app/file.txt`, { credentials: "include" });
+     * @returns {Client}
+     */
+    get client() {
+        const ret = wasm.pubky_client(this.__wbg_ptr);
+        return Client.__wrap(ret);
+    }
+    /**
+     * Create an event stream builder for a specific homeserver.
+     *
+     * Use this when you already know the homeserver pubkey. This avoids
+     * Pkarr resolution overhead. Obtain a homeserver pubkey via `getHomeserverOf()`.
+     *
+     * @param {PublicKey} homeserver - The homeserver public key
+     * @returns {EventStreamBuilder} - Builder for configuring and subscribing to the stream
+     *
+     * @example
+     * ```typescript
+     * const homeserver = await pubky.getHomeserverOf(user1);
+     * const stream = await pubky.eventStreamFor(homeserver)
+     *   .addUsers([[user1.z32(), null], [user2.z32(), null]])
+     *   .live()
+     *   .subscribe();
+     *
+     * for await (const event of stream) {
+     *   console.log(`${event.eventType}: ${event.resource.path}`);
+     * }
+     * ```
+     * @param {PublicKey} homeserver
+     * @returns {EventStreamBuilder}
+     */
+    eventStreamFor(homeserver) {
+        _assertClass(homeserver, PublicKey);
+        const ret = wasm.pubky_eventStreamFor(this.__wbg_ptr, homeserver.__wbg_ptr);
+        return EventStreamBuilder.__wrap(ret);
+    }
+    /**
+     * Create an event stream builder for a single user.
+     *
+     * This is the simplest way to subscribe to events for one user. The homeserver
+     * is automatically resolved from the user's Pkarr record.
+     *
+     * @param {PublicKey} user - The user's public key
+     * @param {string | null} cursor - Optional cursor position to start from
+     * @returns {EventStreamBuilder} - Builder for configuring and subscribing to the stream
+     *
+     * @example
+     * ```typescript
+     * const user = PublicKey.from("o1gg96ewuojmopcjbz8895478wdtxtzzuxnfjjz8o8e77csa1ngo");
+     * const stream = await pubky.eventStreamForUser(user, null)
+     *   .live()
+     *   .subscribe();
+     *
+     * for await (const event of stream) {
+     *   console.log(`${event.eventType}: ${event.resource.path}`);
+     * }
+     * ```
+     * @param {PublicKey} user
+     * @param {string | null} [cursor]
+     * @returns {EventStreamBuilder}
+     */
+    eventStreamForUser(user, cursor) {
+        _assertClass(user, PublicKey);
+        var ptr0 = isLikeNone(cursor) ? 0 : passStringToWasm0(cursor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pubky_eventStreamForUser(this.__wbg_ptr, user.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return EventStreamBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Resolve the homeserver for a given public key (read-only).
+     *
+     * Uses an internal read-only Pkdns actor.
+     *
+     * @param {PublicKey} user
+     * @returns {Promise<PublicKey|undefined>} Homeserver public key or `undefined` if not found.
+     * @param {PublicKey} user_public_key
+     * @returns {Promise<PublicKey | undefined>}
+     */
+    getHomeserverOf(user_public_key) {
+        _assertClass(user_public_key, PublicKey);
+        const ret = wasm.pubky_getHomeserverOf(this.__wbg_ptr, user_public_key.__wbg_ptr);
+        return ret;
+    }
     /**
      * Create a Pubky facade wired for **mainnet** defaults (public relays).
      *
@@ -1253,45 +1208,58 @@ class Pubky {
         return this;
     }
     /**
-     * Create a Pubky facade preconfigured for a **local testnet**.
+     * Public, unauthenticated storage API.
      *
-     * 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`).
+     * Use for **read-only** public access via addressed paths:
+     * `"pubky<user>/pub/…"`.
      *
-     * @param {string=} host Optional host (e.g. `"localhost"`, `"docker-host"`, `"127.0.0.1"`).
-     * @returns {Pubky}
+     * @returns {PublicStorage}
      *
      * @example
-     * const pubky = Pubky.testnet();              // localhost default
-     * const pubky = Pubky.testnet("docker-host"); // custom hostname/IP
-     * @param {string | null} [host]
-     * @returns {Pubky}
+     * const text = await pubky.publicStorage.getText(`${userPk.toString()}/pub/example.com/hello.txt`);
+     * @returns {PublicStorage}
+     */
+    get publicStorage() {
+        const ret = wasm.pubky_publicStorage(this.__wbg_ptr);
+        return PublicStorage.__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>}
      */
-    static testnet(host) {
-        var ptr0 = isLikeNone(host) ? 0 : passStringToWasm0(host, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.pubky_testnet(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Pubky.__wrap(ret[0]);
+    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;
     }
     /**
-     * Wrap an existing configured HTTP client into a Pubky facade.
+     * Create a `Signer` from an existing `Keypair`.
      *
-     * @param {Client} client A previously constructed client.
-     * @returns {Pubky}
+     * @param {Keypair} keypair The user’s keys.
+     * @returns {Signer}
      *
      * @example
-     * const client = Client.testnet();
-     * const pubky = Pubky.withClient(client);
-     * @param {Client} client
-     * @returns {Pubky}
+     * const signer = pubky.signer(Keypair.random());
+     * const session = await signer.signup(homeserverPk, null);
+     * @param {Keypair} keypair
+     * @returns {Signer}
      */
-    static withClient(client) {
-        _assertClass(client, Client);
-        const ret = wasm.pubky_withClient(client.__wbg_ptr);
-        return Pubky.__wrap(ret);
+    signer(keypair) {
+        _assertClass(keypair, Keypair);
+        const ret = wasm.pubky_signer(this.__wbg_ptr, keypair.__wbg_ptr);
+        return Signer.__wrap(ret);
     }
     /**
      * Start a **pubkyauth** flow.
@@ -1308,7 +1276,7 @@ class Pubky {
      * 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/"`).
+     * @param {string=} relay Optional HTTP relay base (e.g. `"https://…/inbox/"`).
      * @returns {AuthFlow}
      * A running auth flow. Show `authorizationUrl` as QR/deeplink,
      * then `awaitApproval()` to obtain a `Session`.
@@ -1340,135 +1308,121 @@ class Pubky {
         return AuthFlow.__wrap(ret[0]);
     }
     /**
-     * Create a `Signer` from an existing `Keypair`.
-     *
-     * @param {Keypair} keypair The user’s keys.
-     * @returns {Signer}
-     *
-     * @example
-     * const signer = pubky.signer(Keypair.random());
-     * const session = await signer.signup(homeserverPk, null);
-     * @param {Keypair} keypair
-     * @returns {Signer}
-     */
-    signer(keypair) {
-        _assertClass(keypair, Keypair);
-        const ret = wasm.pubky_signer(this.__wbg_ptr, keypair.__wbg_ptr);
-        return Signer.__wrap(ret);
-    }
-    /**
-     * Public, unauthenticated storage API.
-     *
-     * Use for **read-only** public access via addressed paths:
-     * `"pubky<user>/pub/…"`.
-     *
-     * @returns {PublicStorage}
-     *
-     * @example
-     * const text = await pubky.publicStorage.getText(`${userPk.toString()}/pub/example.com/hello.txt`);
-     * @returns {PublicStorage}
-     */
-    get publicStorage() {
-        const ret = wasm.pubky_client(this.__wbg_ptr);
-        return PublicStorage.__wrap(ret);
-    }
-    /**
-     * Resolve the homeserver for a given public key (read-only).
-     *
-     * Uses an internal read-only Pkdns actor.
+     * Create a Pubky facade preconfigured for a **local testnet**.
      *
-     * @param {PublicKey} user
-     * @returns {Promise<PublicKey|undefined>} Homeserver public key or `undefined` if not found.
-     * @param {PublicKey} user_public_key
-     * @returns {Promise<PublicKey | undefined>}
-     */
-    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).
+     * 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`).
      *
-     * @returns {Client}
-     * Use this for low-level `fetch()` calls or testing with raw URLs.
+     * @param {string=} host Optional host (e.g. `"localhost"`, `"docker-host"`, `"127.0.0.1"`).
+     * @returns {Pubky}
      *
      * @example
-     * const r = await pubky.client.fetch(`pubky://${userPk.z32()}/pub/app/file.txt`, { credentials: "include" });
-     * @returns {Client}
+     * const pubky = Pubky.testnet();              // localhost default
+     * const pubky = Pubky.testnet("docker-host"); // custom hostname/IP
+     * @param {string | null} [host]
+     * @returns {Pubky}
      */
-    get client() {
-        const ret = wasm.pubky_client(this.__wbg_ptr);
-        return Client.__wrap(ret);
+    static testnet(host) {
+        var ptr0 = isLikeNone(host) ? 0 : passStringToWasm0(host, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pubky_testnet(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Pubky.__wrap(ret[0]);
     }
     /**
-     * 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.
+     * Wrap an existing configured HTTP client into a Pubky facade.
      *
-     * @param {string} exported A string produced by `session.export()`.
-     * @returns {Promise<Session>}
-     * A rehydrated session bound to this SDK's HTTP client.
+     * @param {Client} client A previously constructed client.
+     * @returns {Pubky}
      *
      * @example
-     * const restored = await pubky.restoreSession(localStorage.getItem("pubky-session")!);
-     * @param {string} exported
-     * @returns {Promise<Session>}
+     * const client = Client.testnet();
+     * const pubky = Pubky.withClient(client);
+     * @param {Client} client
+     * @returns {Pubky}
      */
-    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;
+    static withClient(client) {
+        _assertClass(client, Client);
+        const ret = wasm.pubky_withClient(client.__wbg_ptr);
+        return Pubky.__wrap(ret);
     }
 }
 if (Symbol.dispose) Pubky.prototype[Symbol.dispose] = Pubky.prototype.free;
-
 exports.Pubky = Pubky;
 
-const PublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_publickey_free(ptr >>> 0, 1));
-
-class PublicKey {
-
+/**
+ * An addressed resource: a user's public key paired with an absolute path.
+ *
+ * This represents a specific file or directory on a user's homeserver.
+ *
+ * @example
+ * ```typescript
+ * // Parse from a pubky URL
+ * const resource = PubkyResource.parse("pubky://o1gg96ewuojmopcjbz8895478wdtxtzzuxnfjjz8o8e77csa1ngo/pub/example.txt");
+ * console.log(resource.owner.z32()); // The user's public key
+ * console.log(resource.path);        // "/pub/example.txt"
+ * console.log(resource.toPubkyUrl()); // "pubky://o1gg96.../pub/example.txt"
+ * ```
+ */
+class PubkyResource {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(PublicKey.prototype);
+        const obj = Object.create(PubkyResource.prototype);
         obj.__wbg_ptr = ptr;
-        PublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        PubkyResourceFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PublicKeyFinalization.unregister(this);
+        PubkyResourceFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_publickey_free(ptr, 0);
+        wasm.__wbg_pubkyresource_free(ptr, 0);
     }
     /**
-     * Convert the PublicKey to Uint8Array
-     * @returns {Uint8Array}
+     * Get the owner's public key.
+     * @returns {PublicKey}
      */
-    toUint8Array() {
-        const ret = wasm.publickey_toUint8Array(this.__wbg_ptr);
-        return ret;
+    get owner() {
+        const ret = wasm.pubkyresource_owner(this.__wbg_ptr);
+        return PublicKey.__wrap(ret);
     }
     /**
-     * Returns the z-base32 encoding of this public key
+     * Parse a pubky resource from a string.
+     *
+     * Accepts:
+     * - `pubky://<public_key>/<path>` (URL form)
+     * - `pubky<public_key>/<path>` (identifier form)
+     *
+     * @param {string} value - The resource string to parse
+     * @returns {PubkyResource} - The parsed resource
+     * @throws {Error} - If the string is not a valid pubky resource
+     * @param {string} value
+     * @returns {PubkyResource}
+     */
+    static parse(value) {
+        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pubkyresource_parse(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PubkyResource.__wrap(ret[0]);
+    }
+    /**
+     * Get the absolute path (e.g., "/pub/example.txt").
      * @returns {string}
      */
-    z32() {
+    get path() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.publickey_z32(this.__wbg_ptr);
+            const ret = wasm.pubkyresource_path(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -1477,15 +1431,30 @@ class PublicKey {
         }
     }
     /**
-     * Returns the identifier form with the `pubky` prefix.
-     * Use for display only; transport/storage should use `.z32()`.
+     * Render as `pubky://<owner>/<path>` (deep-link/URL form).
+     * @returns {string}
+     */
+    toPubkyUrl() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.pubkyresource_toPubkyUrl(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);
+        }
+    }
+    /**
+     * Render as `pubky<owner>/<path>` (identifier form).
      * @returns {string}
      */
     toString() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.publickey_toString(this.__wbg_ptr);
+            const ret = wasm.pubkyresource_toString(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -1493,6 +1462,28 @@ class PublicKey {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+}
+if (Symbol.dispose) PubkyResource.prototype[Symbol.dispose] = PubkyResource.prototype.free;
+exports.PubkyResource = PubkyResource;
+
+class PublicKey {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PublicKey.prototype);
+        obj.__wbg_ptr = ptr;
+        PublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PublicKeyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_publickey_free(ptr, 0);
+    }
     /**
      * @throws
      * @param {string} value
@@ -1507,19 +1498,55 @@ class PublicKey {
         }
         return PublicKey.__wrap(ret[0]);
     }
+    /**
+     * Returns the identifier form with the `pubky` prefix.
+     * Use for display only; transport/storage should use `.z32()`.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.publickey_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);
+        }
+    }
+    /**
+     * Convert the PublicKey to Uint8Array
+     * @returns {Uint8Array}
+     */
+    toUint8Array() {
+        const ret = wasm.publickey_toUint8Array(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the z-base32 encoding of this public key
+     * @returns {string}
+     */
+    z32() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.publickey_z32(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) PublicKey.prototype[Symbol.dispose] = PublicKey.prototype.free;
-
 exports.PublicKey = PublicKey;
 
-const PublicStorageFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_publicstorage_free(ptr >>> 0, 1));
 /**
  * Read-only public storage using addressed paths (`"pubky<user>/pub/..."`).
  */
 class PublicStorage {
-
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(PublicStorage.prototype);
@@ -1527,52 +1554,28 @@ class PublicStorage {
         PublicStorageFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         PublicStorageFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_publicstorage_free(ptr, 0);
     }
     /**
-     * Construct PublicStorage using global client (mainline relays).
-     */
-    constructor() {
-        const ret = wasm.publicstorage_new();
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        PublicStorageFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * List a directory. Results are `pubky://…` identifier URLs.
+     * Check if a path exists.
      *
-     * @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 {Address} address
-     * @param {string | null} [cursor]
-     * @param {boolean | null} [reverse]
-     * @param {number | null} [limit]
-     * @param {boolean | null} [shallow]
-     * @returns {Promise<string[]>}
+     * @returns {Promise<boolean>}
+     * @param {Address} address
+     * @returns {Promise<boolean>}
      */
-    list(address, cursor, reverse, limit, shallow) {
+    exists(address) {
         const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(cursor) ? 0 : passStringToWasm0(cursor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        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);
+        const ret = wasm.publicstorage_exists(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
@@ -1603,6 +1606,20 @@ class PublicStorage {
         const ret = wasm.publicstorage_getBytes(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * Fetch JSON from an addressed path.
+     *
+     * @param {Address} address `"pubky<user>/pub/.../file.json"` (preferred) or `pubky://<user>/pub/...`.
+     * @returns {Promise<any>}
+     * @param {Address} address
+     * @returns {Promise<any>}
+     */
+    getJson(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.publicstorage_getJson(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * Fetch text from an addressed path as UTF-8 text.
      *
@@ -1618,32 +1635,40 @@ class PublicStorage {
         return ret;
     }
     /**
-     * Fetch JSON from an addressed path.
+     * List a directory. Results are `pubky://…` identifier URLs.
      *
-     * @param {Address} address `"pubky<user>/pub/.../file.json"` (preferred) or `pubky://<user>/pub/...`.
-     * @returns {Promise<any>}
+     * @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 {Address} address
-     * @returns {Promise<any>}
+     * @param {string | null} [cursor]
+     * @param {boolean | null} [reverse]
+     * @param {number | null} [limit]
+     * @param {boolean | null} [shallow]
+     * @returns {Promise<string[]>}
      */
-    getJson(address) {
+    list(address, cursor, reverse, limit, shallow) {
         const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.publicstorage_getJson(this.__wbg_ptr, ptr0, len0);
+        var ptr1 = isLikeNone(cursor) ? 0 : passStringToWasm0(cursor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        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;
     }
     /**
-     * Check if a path exists.
-     *
-     * @param {Address} address
-     * @returns {Promise<boolean>}
-     * @param {Address} address
-     * @returns {Promise<boolean>}
+     * Construct PublicStorage using global client (mainline relays).
      */
-    exists(address) {
-        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.publicstorage_exists(this.__wbg_ptr, ptr0, len0);
-        return ret;
+    constructor() {
+        const ret = wasm.publicstorage_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        PublicStorageFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
      * Get metadata for an address
@@ -1662,15 +1687,9 @@ class 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);
@@ -1678,14 +1697,12 @@ class SeedExportDeepLink {
         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);
@@ -1727,19 +1744,14 @@ class SeedExportDeepLink {
     }
 }
 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`)
  * - Cookie is managed automatically by the underlying fetch client
  */
 class Session {
-
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(Session.prototype);
@@ -1747,49 +1759,16 @@ class Session {
         SessionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SessionFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_session_free(ptr, 0);
     }
-    /**
-     * Retrieve immutable info about this session (user & capabilities).
-     *
-     * @returns {SessionInfo}
-     * @returns {SessionInfo}
-     */
-    get info() {
-        const ret = wasm.session_info(this.__wbg_ptr);
-        return SessionInfo.__wrap(ret);
-    }
-    /**
-     * Access the session-scoped storage API (read/write).
-     *
-     * @returns {SessionStorage}
-     * @returns {SessionStorage}
-     */
-    get storage() {
-        const ret = wasm.session_storage(this.__wbg_ptr);
-        return SessionStorage.__wrap(ret);
-    }
-    /**
-     * Invalidate the session on the server (clears server cookie).
-     * Further calls to storage API will fail.
-     *
-     * @returns {Promise<void>}
-     * @returns {Promise<void>}
-     */
-    signout() {
-        const ret = wasm.session_signout(this.__wbg_ptr);
-        return ret;
-    }
     /**
      * Export the session metadata so it can be restored after a tab refresh.
      *
@@ -1812,6 +1791,16 @@ class Session {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Retrieve immutable info about this session (user & capabilities).
+     *
+     * @returns {SessionInfo}
+     * @returns {SessionInfo}
+     */
+    get info() {
+        const ret = wasm.session_info(this.__wbg_ptr);
+        return SessionInfo.__wrap(ret);
+    }
     /**
      * Restore a session from an `export()` string.
      *
@@ -1838,19 +1827,35 @@ class Session {
         const ret = wasm.session_restore(ptr0, len0, ptr1);
         return ret;
     }
+    /**
+     * Invalidate the session on the server (clears server cookie).
+     * Further calls to storage API will fail.
+     *
+     * @returns {Promise<void>}
+     * @returns {Promise<void>}
+     */
+    signout() {
+        const ret = wasm.session_signout(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Access the session-scoped storage API (read/write).
+     *
+     * @returns {SessionStorage}
+     * @returns {SessionStorage}
+     */
+    get storage() {
+        const ret = wasm.session_storage(this.__wbg_ptr);
+        return SessionStorage.__wrap(ret);
+    }
 }
 if (Symbol.dispose) Session.prototype[Symbol.dispose] = Session.prototype.free;
-
 exports.Session = Session;
 
-const SessionInfoFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_sessioninfo_free(ptr >>> 0, 1));
 /**
  * Static snapshot of session metadata.
  */
 class SessionInfo {
-
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(SessionInfo.prototype);
@@ -1858,18 +1863,28 @@ class SessionInfo {
         SessionInfoFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SessionInfoFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_sessioninfo_free(ptr, 0);
     }
+    /**
+     * Effective capabilities granted to this session.
+     *
+     * @returns {string[]} Normalized capability entries (e.g. `"/pub/app/:rw"`).
+     * @returns {string[]}
+     */
+    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;
+    }
     /**
      * The user’s public key for this session.
      *
@@ -1886,31 +1901,14 @@ class SessionInfo {
         const ret = wasm.sessioninfo_publicKey(this.__wbg_ptr);
         return PublicKey.__wrap(ret);
     }
-    /**
-     * Effective capabilities granted to this session.
-     *
-     * @returns {string[]} Normalized capability entries (e.g. `"/pub/app/:rw"`).
-     * @returns {string[]}
-     */
-    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;
-    }
 }
 if (Symbol.dispose) SessionInfo.prototype[Symbol.dispose] = SessionInfo.prototype.free;
-
 exports.SessionInfo = SessionInfo;
 
-const SessionStorageFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_sessionstorage_free(ptr >>> 0, 1));
 /**
  * Read/write storage scoped to **your** session (absolute paths: `/pub/...`).
  */
 class SessionStorage {
-
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(SessionStorage.prototype);
@@ -1918,40 +1916,42 @@ class SessionStorage {
         SessionStorageFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SessionStorageFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_sessionstorage_free(ptr, 0);
     }
     /**
-     * List a directory (absolute session path). Returns `pubky://…` URLs.
+     * Delete a path (file or empty directory).
      *
-     * @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 {Path} path
-     * @param {string | null} [cursor]
-     * @param {boolean | null} [reverse]
-     * @param {number | null} [limit]
-     * @param {boolean | null} [shallow]
-     * @returns {Promise<string[]>}
+     * @returns {Promise<void>}
+     * @param {Path} path
+     * @returns {Promise<void>}
      */
-    list(path, cursor, reverse, limit, shallow) {
+    delete(path) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(cursor) ? 0 : passStringToWasm0(cursor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        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);
+        const ret = wasm.sessionstorage_delete(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Check existence.
+     *
+     * @param {Path} path
+     * @returns {Promise<boolean>}
+     * @param {Path} path
+     * @returns {Promise<boolean>}
+     */
+    exists(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sessionstorage_exists(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
@@ -1982,20 +1982,6 @@ class SessionStorage {
         const ret = wasm.sessionstorage_getBytes(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
-    /**
-     * GET text from an absolute session path.
-     *
-     * @param {Path} path
-     * @returns {Promise<string>}
-     * @param {Path} path
-     * @returns {Promise<string>}
-     */
-    getText(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.sessionstorage_getText(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
     /**
      * GET JSON from an absolute session path.
      *
@@ -2011,32 +1997,41 @@ class SessionStorage {
         return ret;
     }
     /**
-     * Check existence.
+     * GET text from an absolute session path.
      *
      * @param {Path} path
-     * @returns {Promise<boolean>}
+     * @returns {Promise<string>}
      * @param {Path} path
-     * @returns {Promise<boolean>}
+     * @returns {Promise<string>}
      */
-    exists(path) {
+    getText(path) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.sessionstorage_exists(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.sessionstorage_getText(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
-     * Get metadata for an absolute, session-scoped path (e.g. `"/pub/app/file.json"`).
+     * List a directory (absolute session path). Returns `pubky://…` URLs.
      *
-     * @param {Path} path Absolute path under your user (starts with `/`).
-     * @returns {Promise<ResourceStats|undefined>} `undefined` if the resource does not exist.
-     * @throws {PubkyError} On invalid input or transport/server errors.
+     * @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 {Path} path
-     * @returns {Promise<ResourceStats | undefined>}
+     * @param {string | null} [cursor]
+     * @param {boolean | null} [reverse]
+     * @param {number | null} [limit]
+     * @param {boolean | null} [shallow]
+     * @returns {Promise<string[]>}
      */
-    stats(path) {
+    list(path, cursor, reverse, limit, shallow) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.sessionstorage_stats(this.__wbg_ptr, ptr0, len0);
+        var ptr1 = isLikeNone(cursor) ? 0 : passStringToWasm0(cursor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        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;
     }
     /**
@@ -2057,6 +2052,22 @@ class SessionStorage {
         const ret = wasm.sessionstorage_putBytes(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
+    /**
+     * PUT JSON at an absolute session path.
+     *
+     * @param {Path} path Absolute path (e.g. `"/pub/app/data.json"`).
+     * @param {any} value JSON-serializable value.
+     * @returns {Promise<void>}
+     * @param {Path} path
+     * @param {any} body
+     * @returns {Promise<void>}
+     */
+    putJson(path, body) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sessionstorage_putJson(this.__wbg_ptr, ptr0, len0, body);
+        return ret;
+    }
     /**
      * PUT text at an absolute session path.
      *
@@ -2076,1172 +2087,1438 @@ class SessionStorage {
         return ret;
     }
     /**
-     * PUT JSON at an absolute session path.
+     * Get metadata for an absolute, session-scoped path (e.g. `"/pub/app/file.json"`).
      *
-     * @param {Path} path Absolute path (e.g. `"/pub/app/data.json"`).
-     * @param {any} value JSON-serializable value.
-     * @returns {Promise<void>}
+     * @param {Path} path Absolute path under your user (starts with `/`).
+     * @returns {Promise<ResourceStats|undefined>} `undefined` if the resource does not exist.
+     * @throws {PubkyError} On invalid input or transport/server errors.
      * @param {Path} path
-     * @param {any} body
+     * @returns {Promise<ResourceStats | undefined>}
+     */
+    stats(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sessionstorage_stats(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) SessionStorage.prototype[Symbol.dispose] = SessionStorage.prototype.free;
+exports.SessionStorage = SessionStorage;
+
+/**
+ * Holds a user’s `Keypair` and performs identity operations:
+ * - `signup` creates a new homeserver user.
+ * - `signin` creates a homeserver session for an existing user.
+ * - Approve pubkyauth requests
+ * - Publish PKDNS when signer-bound
+ */
+class Signer {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Signer.prototype);
+        obj.__wbg_ptr = ptr;
+        SignerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signer_free(ptr, 0);
+    }
+    /**
+     * Approve a `pubkyauth://` request URL (encrypts & POSTs the signed AuthToken).
+     * @param {string} pubkyauth_url
      * @returns {Promise<void>}
      */
-    putJson(path, body) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.sessionstorage_putJson(this.__wbg_ptr, ptr0, len0, body);
+    approveAuthRequest(pubkyauth_url) {
+        const ptr0 = passStringToWasm0(pubkyauth_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signer_approveAuthRequest(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Create a signer from a `Keypair` (prefer `pubky.signer(kp)`).
+     *
+     * @param {Keypair} keypair
+     * @returns {Signer}
+     * @param {Keypair} keypair
+     * @returns {Signer}
+     */
+    static fromKeypair(keypair) {
+        _assertClass(keypair, Keypair);
+        const ret = wasm.signer_fromKeypair(keypair.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Signer.__wrap(ret[0]);
+    }
+    /**
+     * Get a PKDNS actor bound to this signer's client & keypair (publishing enabled).
+     *
+     * @returns {Pkdns}
+     *
+     * @example
+     * await signer.pkdns.publishHomeserverIfStale(homeserverPk);
+     * @returns {Pkdns}
+     */
+    get pkdns() {
+        const ret = wasm.signer_pkdns(this.__wbg_ptr);
+        return Pkdns.__wrap(ret);
+    }
+    /**
+     * Get the public key of this signer.
+     *
+     * @returns {PublicKey}
+     * @returns {PublicKey}
+     */
+    get publicKey() {
+        const ret = wasm.signer_publicKey(this.__wbg_ptr);
+        return PublicKey.__wrap(ret);
+    }
+    /**
+     * Fast sign-in for a returning user. Publishes PKDNS in the background.
+     *
+     * Creates a valid homeserver Session with root capabilities
+     *
+     * @returns {Promise<Session>}
+     *
+     * @throws {PubkyError}
+     * @returns {Promise<Session>}
+     */
+    signin() {
+        const ret = wasm.signer_signin(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Blocking sign-in. Waits for PKDNS publish to complete (slower; safer).
+     *
+     * Creates a valid homeserver Session with root capabilities
+     *
+     * @returns {Promise<Session>}
+     * @returns {Promise<Session>}
+     */
+    signinBlocking() {
+        const ret = wasm.signer_signinBlocking(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Sign up at a homeserver. Returns a ready `Session`.
+     *
+     * Creates a valid homeserver Session with root capabilities
+     *
+     * @param {PublicKey} homeserver The homeserver’s public key.
+     * @param {string|null} signupToken Invite/registration token or `null`.
+     * @returns {Promise<Session>}
+     *
+     * @throws {PubkyError}
+     * - `AuthenticationError` (bad/expired token)
+     * - `RequestError` (network/server)
+     * @param {PublicKey} homeserver
+     * @param {string | null} [signup_token]
+     * @returns {Promise<Session>}
+     */
+    signup(homeserver, signup_token) {
+        _assertClass(homeserver, PublicKey);
+        var ptr0 = isLikeNone(signup_token) ? 0 : passStringToWasm0(signup_token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signer_signup(this.__wbg_ptr, homeserver.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) Signer.prototype[Symbol.dispose] = Signer.prototype.free;
+exports.Signer = Signer;
+
+class SigninDeepLink {
+    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);
+    }
+    /**
+     * @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 {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);
+        }
+    }
+    /**
+     * @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 {Uint8Array}
+     */
+    get secret() {
+        const ret = wasm.signindeeplink_secret(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Delete a path (file or empty directory).
-     *
-     * @param {Path} path
-     * @returns {Promise<void>}
-     * @param {Path} path
-     * @returns {Promise<void>}
+     * @returns {string}
      */
-    delete(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.sessionstorage_delete(this.__wbg_ptr, ptr0, len0);
-        return ret;
+    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) SessionStorage.prototype[Symbol.dispose] = SessionStorage.prototype.free;
-
-exports.SessionStorage = SessionStorage;
-
-const SignerFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_signer_free(ptr >>> 0, 1));
-/**
- * Holds a user’s `Keypair` and performs identity operations:
- * - `signup` creates a new homeserver user.
- * - `signin` creates a homeserver session for an existing user.
- * - Approve pubkyauth requests
- * - Publish PKDNS when signer-bound
- */
-class Signer {
+if (Symbol.dispose) SigninDeepLink.prototype[Symbol.dispose] = SigninDeepLink.prototype.free;
+exports.SigninDeepLink = SigninDeepLink;
 
+class SignupDeepLink {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Signer.prototype);
+        const obj = Object.create(SignupDeepLink.prototype);
         obj.__wbg_ptr = ptr;
-        SignerFinalization.register(obj, obj.__wbg_ptr, obj);
+        SignupDeepLinkFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SignerFinalization.unregister(this);
+        SignupDeepLinkFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_signer_free(ptr, 0);
+        wasm.__wbg_signupdeeplink_free(ptr, 0);
     }
     /**
-     * Create a signer from a `Keypair` (prefer `pubky.signer(kp)`).
-     *
-     * @param {Keypair} keypair
-     * @returns {Signer}
-     * @param {Keypair} keypair
-     * @returns {Signer}
+     * @returns {string}
      */
-    static fromKeypair(keypair) {
-        _assertClass(keypair, Keypair);
-        const ret = wasm.signer_fromKeypair(keypair.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    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 {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);
         }
-        return Signer.__wrap(ret[0]);
     }
     /**
-     * Get the public key of this signer.
-     *
-     * @returns {PublicKey}
      * @returns {PublicKey}
      */
-    get publicKey() {
-        const ret = wasm.signer_publicKey(this.__wbg_ptr);
+    get homeserver() {
+        const ret = wasm.signupdeeplink_homeserver(this.__wbg_ptr);
         return PublicKey.__wrap(ret);
     }
     /**
-     * Sign up at a homeserver. Returns a ready `Session`.
-     *
-     * Creates a valid homeserver Session with root capabilities
-     *
-     * @param {PublicKey} homeserver The homeserver’s public key.
-     * @param {string|null} signupToken Invite/registration token or `null`.
-     * @returns {Promise<Session>}
-     *
-     * @throws {PubkyError}
-     * - `AuthenticationError` (bad/expired token)
-     * - `RequestError` (network/server)
-     * @param {PublicKey} homeserver
-     * @param {string | null} [signup_token]
-     * @returns {Promise<Session>}
+     * @param {string} url
+     * @returns {SignupDeepLink}
      */
-    signup(homeserver, signup_token) {
-        _assertClass(homeserver, PublicKey);
-        var ptr0 = isLikeNone(signup_token) ? 0 : passStringToWasm0(signup_token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.signer_signup(this.__wbg_ptr, homeserver.__wbg_ptr, ptr0, len0);
-        return ret;
+    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]);
     }
     /**
-     * Fast sign-in for a returning user. Publishes PKDNS in the background.
-     *
-     * Creates a valid homeserver Session with root capabilities
-     *
-     * @returns {Promise<Session>}
-     *
-     * @throws {PubkyError}
-     * @returns {Promise<Session>}
+     * @returns {Uint8Array}
      */
-    signin() {
-        const ret = wasm.signer_signin(this.__wbg_ptr);
+    get secret() {
+        const ret = wasm.signupdeeplink_secret(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Blocking sign-in. Waits for PKDNS publish to complete (slower; safer).
-     *
-     * Creates a valid homeserver Session with root capabilities
-     *
-     * @returns {Promise<Session>}
-     * @returns {Promise<Session>}
+     * @returns {string | undefined}
      */
-    signinBlocking() {
-        const ret = wasm.signer_signinBlocking(this.__wbg_ptr);
-        return ret;
+    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;
     }
     /**
-     * Approve a `pubkyauth://` request URL (encrypts & POSTs the signed AuthToken).
-     * @param {string} pubkyauth_url
-     * @returns {Promise<void>}
+     * @returns {string}
      */
-    approveAuthRequest(pubkyauth_url) {
-        const ptr0 = passStringToWasm0(pubkyauth_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    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;
+
+/**
+ * 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}
+ */
+function resolvePubky(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);
+    }
+}
+exports.resolvePubky = resolvePubky;
+
+/**
+ * Set the global logging verbosity for the WASM Pubky SDK. Routes Rust `log` output to the browser console.
+ *
+ * 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 {Level} level
+ *        Minimum log level to enable. One of: "error" | "warn" | "info" | "debug" | "trace".
+ *
+ * @returns {void}
+ *
+ * @throws {Error}
+ *         If `level` is invalid ("Invalid log level") or the logger cannot be initialized
+ *         (e.g., already initialized).
+ *
+ * Usage:
+ *   Call once at application startup, before invoking other SDK APIs.
+ * @param {Level} level
+ */
+function setLogLevel(level) {
+    const ret = wasm.setLogLevel((__wbindgen_enum_Level.indexOf(level) + 1 || 6) - 1);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+exports.setLogLevel = setLogLevel;
+
+/**
+ * Validate and normalize a capabilities string.
+ *
+ * - Normalizes action order (`wr` -> `rw`)
+ * - Throws `InvalidInput` listing malformed entries.
+ *
+ * @param {string} input
+ * @returns {string} Normalized string (same shape as input).
+ * @throws {PubkyError} `{ name: "InvalidInput" }` with a helpful message.
+ * The error's `data` field is `{ invalidEntries: string[] }` listing malformed tokens.
+ * @param {string} input
+ * @returns {string}
+ */
+function validateCapabilities(input) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.signer_approveAuthRequest(this.__wbg_ptr, ptr0, len0);
-        return ret;
+        const ret = wasm.validateCapabilities(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);
     }
-    /**
-     * Get a PKDNS actor bound to this signer's client & keypair (publishing enabled).
-     *
-     * @returns {Pkdns}
-     *
-     * @example
-     * await signer.pkdns.publishHomeserverIfStale(homeserverPk);
-     * @returns {Pkdns}
-     */
-    get pkdns() {
-        const ret = wasm.signer_pkdns(this.__wbg_ptr);
-        return Pkdns.__wrap(ret);
+}
+exports.validateCapabilities = validateCapabilities;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_ecbf49c1b9d07c30: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(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);
+        },
+        __wbg___wbindgen_bigint_get_as_i64_a4925bc53b16f3d6: 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);
+        },
+        __wbg___wbindgen_boolean_get_4a348b369b009243: function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_debug_string_43c7ccb034739216: 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);
+        },
+        __wbg___wbindgen_in_035107858ad0083e: function(arg0, arg1) {
+            const ret = arg0 in arg1;
+            return ret;
+        },
+        __wbg___wbindgen_is_bigint_15e2d080220c7748: function(arg0) {
+            const ret = typeof(arg0) === 'bigint';
+            return ret;
+        },
+        __wbg___wbindgen_is_function_18bea6e84080c016: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_null_c5f5bb76436a9ab1: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_8d3fac158b36498d: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_4d5f2c5b2acf65b0: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_4a711ea9d2e1ef93: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_eq_65f99081d9ee8f4d: function(arg0, arg1) {
+            const ret = arg0 === arg1;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_loose_eq_1a2067dfb025b5ec: function(arg0, arg1) {
+            const ret = arg0 == arg1;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_eed4462ef92e1bed: 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);
+        },
+        __wbg___wbindgen_string_get_d09f733449cbf7a2: 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);
+        },
+        __wbg___wbindgen_throw_df03e93053e0f4bc: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg__wbg_cb_unref_9f02ce912168c354: function(arg0) {
+            arg0._wbg_cb_unref();
+        },
+        __wbg_abort_7100d741d811fdb2: function(arg0, arg1) {
+            arg0.abort(arg1);
+        },
+        __wbg_abort_bf4dbbb6563f9ad6: function(arg0) {
+            arg0.abort();
+        },
+        __wbg_append_057d2867b781cdc3: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_arrayBuffer_6881d775e5087c3c: function() { return handleError(function (arg0) {
+            const ret = arg0.arrayBuffer();
+            return ret;
+        }, arguments); },
+        __wbg_authtoken_new: function(arg0) {
+            const ret = AuthToken.__wrap(arg0);
+            return ret;
+        },
+        __wbg_body_1f1b47b98078274a: function(arg0) {
+            const ret = arg0.body;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_buffer_d8bcb2548b84f613: function(arg0) {
+            const ret = arg0.buffer;
+            return ret;
+        },
+        __wbg_byobRequest_d4c119d77083ad7a: function(arg0) {
+            const ret = arg0.byobRequest;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_byteLength_9f07c790d3b57e52: function(arg0) {
+            const ret = arg0.byteLength;
+            return ret;
+        },
+        __wbg_byteOffset_f141aa06796258e0: function(arg0) {
+            const ret = arg0.byteOffset;
+            return ret;
+        },
+        __wbg_call_85e5437fa1ab109d: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_call_df7a43aecab856a8: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_cancel_9c3f52242a659f49: function(arg0) {
+            const ret = arg0.cancel();
+            return ret;
+        },
+        __wbg_catch_03e7dc8db176651d: function(arg0, arg1) {
+            const ret = arg0.catch(arg1);
+            return ret;
+        },
+        __wbg_clearTimeout_2256f1e7b94ef517: function(arg0) {
+            const ret = clearTimeout(arg0);
+            return ret;
+        },
+        __wbg_close_1d57e0361a94e720: function() { return handleError(function (arg0) {
+            arg0.close();
+        }, arguments); },
+        __wbg_close_29dcd39cb851697f: function() { return handleError(function (arg0) {
+            arg0.close();
+        }, arguments); },
+        __wbg_crypto_38df2bab126b63dc: function(arg0) {
+            const ret = arg0.crypto;
+            return ret;
+        },
+        __wbg_debug_9fa2e16fc1df8e5c: function(arg0, arg1, arg2, arg3) {
+            console.debug(arg0, arg1, arg2, arg3);
+        },
+        __wbg_done_0ad70482cae88a68: function(arg0) {
+            const ret = arg0.done;
+            return ret;
+        },
+        __wbg_enqueue_42644feecc53c816: function() { return handleError(function (arg0, arg1) {
+            arg0.enqueue(arg1);
+        }, arguments); },
+        __wbg_entries_0612723091672151: function(arg0) {
+            const ret = arg0.entries();
+            return ret;
+        },
+        __wbg_entries_d58050057c0390ac: function(arg0) {
+            const ret = Object.entries(arg0);
+            return ret;
+        },
+        __wbg_error_28af238a3cff9f08: function(arg0, arg1, arg2, arg3) {
+            console.error(arg0, arg1, arg2, arg3);
+        },
+        __wbg_event_new: function(arg0) {
+            const ret = Event.__wrap(arg0);
+            return ret;
+        },
+        __wbg_fetch_43b2f110608a59ff: function(arg0) {
+            const ret = fetch(arg0);
+            return ret;
+        },
+        __wbg_fetch_45acaeeb56cea876: function(arg0) {
+            const ret = fetch(arg0);
+            return ret;
+        },
+        __wbg_fetch_8508e14acc7090e7: function(arg0, arg1) {
+            const ret = arg0.fetch(arg1);
+            return ret;
+        },
+        __wbg_from_291708c278f9eb83: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
+        __wbg_getRandomValues_3f44b700395062e5: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_getRandomValues_ab1935b403569652: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
+            arg0.getRandomValues(arg1);
+        }, arguments); },
+        __wbg_getReader_9facd4f899beac89: function() { return handleError(function (arg0) {
+            const ret = arg0.getReader();
+            return ret;
+        }, arguments); },
+        __wbg_get_6f5cf69c8f3f094a: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_c40e2c3262995a8e: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_d0e1306db90b68d9: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_done_7c83ea32e40589f6: function(arg0) {
+            const ret = arg0.done;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg_get_unchecked_3de5bfaaea65f86b: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_value_d01127aa5554a340: function(arg0) {
+            const ret = arg0.value;
+            return ret;
+        },
+        __wbg_has_393943c179c58bfe: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.has(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_headers_5960155bb72206d7: function(arg0) {
+            const ret = arg0.headers;
+            return ret;
+        },
+        __wbg_info_fc55b8d216b2710c: function(arg0, arg1, arg2, arg3) {
+            console.info(arg0, arg1, arg2, arg3);
+        },
+        __wbg_instanceof_ArrayBuffer_d8e4e51f1cf7287a: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Error_bd90cad2d1c17510: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Headers_453883a986b5b9c9: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Headers;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Map_53b6790994271123: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Response_4d70bea95d48a514: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Response;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_6e48d83da6091cc8: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_2efa5973cef6ec32: function(arg0) {
+            const ret = Array.isArray(arg0);
+            return ret;
+        },
+        __wbg_isSafeInteger_6709fb28be12d738: function(arg0) {
+            const ret = Number.isSafeInteger(arg0);
+            return ret;
+        },
+        __wbg_iterator_e77d2b7575cca5a7: function() {
+            const ret = Symbol.iterator;
+            return ret;
+        },
+        __wbg_length_00dd7227fd4626ad: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_5e07cf181b2745fb: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_log_9ce7e40080101249: function(arg0, arg1, arg2, arg3) {
+            console.log(arg0, arg1, arg2, arg3);
+        },
+        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+            const ret = arg0.msCrypto;
+            return ret;
+        },
+        __wbg_new_58794ce12509602d: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_62f131e968c83d75: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_66075f8c2ea6575e: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_74eb411a4d7bd3f1: function() {
+            const ret = new Map();
+            return ret;
+        },
+        __wbg_new_a0479da6258a0d71: function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        },
+        __wbg_new_a23ce0a01d189235: function() { return handleError(function () {
+            const ret = new Headers();
+            return ret;
+        }, arguments); },
+        __wbg_new_eb8f6841a0421871: function() { return handleError(function () {
+            const ret = new AbortController();
+            return ret;
+        }, arguments); },
+        __wbg_new_from_slice_e98c2bb0a59c32a0: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_typed_893dbec5fe999814: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen__convert__closures_____invoke__h2ffe4d8ada5ad683(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = state0.b = 0;
+            }
+        },
+        __wbg_new_with_byte_offset_and_length_5c494ef1df19d087: function(arg0, arg1, arg2) {
+            const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_into_underlying_source_fd904252f385f59c: function(arg0, arg1) {
+            const ret = new ReadableStream(IntoUnderlyingSource.__wrap(arg0), arg1);
+            return ret;
+        },
+        __wbg_new_with_length_9b57e4a9683723fa: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_opt_readable_stream_and_init_404b48c41e625497: function() { return handleError(function (arg0, arg1) {
+            const ret = new Response(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_new_with_str_and_init_ccd7de5a7b7630b8: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
+            return ret;
+        }, arguments); },
+        __wbg_next_5428439dfc1d0362: function() { return handleError(function (arg0) {
+            const ret = arg0.next();
+            return ret;
+        }, arguments); },
+        __wbg_next_d314789a105729f3: function(arg0) {
+            const ret = arg0.next;
+            return ret;
+        },
+        __wbg_node_84ea875411254db1: function(arg0) {
+            const ret = arg0.node;
+            return ret;
+        },
+        __wbg_now_81a04fc60f4b9917: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_now_e7c6795a7f81e10f: function(arg0) {
+            const ret = arg0.now();
+            return ret;
+        },
+        __wbg_parse_18a4a613f7a65376: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return ret;
+        }, arguments); },
+        __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
+            const ret = arg0.performance;
+            return ret;
+        },
+        __wbg_process_44c7a14e11e9f69e: function(arg0) {
+            const ret = arg0.process;
+            return ret;
+        },
+        __wbg_prototypesetcall_d1a7133bc8d83aa9: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_publickey_new: function(arg0) {
+            const ret = PublicKey.__wrap(arg0);
+            return ret;
+        },
+        __wbg_queueMicrotask_622e69f0935dfab2: function(arg0) {
+            const ret = arg0.queueMicrotask;
+            return ret;
+        },
+        __wbg_queueMicrotask_d0528786d26e067c: function(arg0) {
+            queueMicrotask(arg0);
+        },
+        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
+            arg0.randomFillSync(arg1);
+        }, arguments); },
+        __wbg_read_af39a65adb693c12: function(arg0) {
+            const ret = arg0.read();
+            return ret;
+        },
+        __wbg_releaseLock_d3d7bbf2efd5c049: function(arg0) {
+            arg0.releaseLock();
+        },
+        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
+            const ret = module.require;
+            return ret;
+        }, arguments); },
+        __wbg_resolve_d170483d75a2c8a1: function(arg0) {
+            const ret = Promise.resolve(arg0);
+            return ret;
+        },
+        __wbg_respond_0beb7807b2a4bc16: function() { return handleError(function (arg0, arg1) {
+            arg0.respond(arg1 >>> 0);
+        }, arguments); },
+        __wbg_session_new: function(arg0) {
+            const ret = Session.__wrap(arg0);
+            return ret;
+        },
+        __wbg_setTimeout_b188b3bcc8977c7d: function(arg0, arg1) {
+            const ret = setTimeout(arg0, arg1);
+            return ret;
+        },
+        __wbg_set_3ba5af57f57f831c: function(arg0, arg1, arg2) {
+            const ret = arg0.set(arg1, arg2);
+            return ret;
+        },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
+        __wbg_set_7bf9e2df46e7632c: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        },
+        __wbg_set_8326741805409e83: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_set_8540e567c8d5d225: function(arg0, arg1, arg2) {
+            arg0.set(getArrayU8FromWasm0(arg1, arg2));
+        },
+        __wbg_set_body_d3bfb0ba84038563: function(arg0, arg1) {
+            arg0.body = arg1;
+        },
+        __wbg_set_cache_d7fd96d5c85d5834: function(arg0, arg1) {
+            arg0.cache = __wbindgen_enum_RequestCache[arg1];
+        },
+        __wbg_set_credentials_75d65e7cc277aad0: function(arg0, arg1) {
+            arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
+        },
+        __wbg_set_db2c2258160ed058: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_set_headers_dc82e2bf93dcda1f: function(arg0, arg1) {
+            arg0.headers = arg1;
+        },
+        __wbg_set_headers_e4e56fe005f0b5c9: function(arg0, arg1) {
+            arg0.headers = arg1;
+        },
+        __wbg_set_high_water_mark_bede7db72aae0904: function(arg0, arg1) {
+            arg0.highWaterMark = arg1;
+        },
+        __wbg_set_method_e1291768ddb1e35e: function(arg0, arg1, arg2) {
+            arg0.method = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_mode_1fcb26983836e884: function(arg0, arg1) {
+            arg0.mode = __wbindgen_enum_RequestMode[arg1];
+        },
+        __wbg_set_name_280167a140c1fb41: function(arg0, arg1, arg2) {
+            arg0.name = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_signal_4e03877dd7f2cd34: function(arg0, arg1) {
+            arg0.signal = arg1;
+        },
+        __wbg_set_status_b9add1436f357a74: function(arg0, arg1) {
+            arg0.status = arg1;
+        },
+        __wbg_set_status_text_8c6fbf561566cfb8: function(arg0, arg1, arg2) {
+            arg0.statusText = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_signal_065197e577ceaa9e: function(arg0) {
+            const ret = arg0.signal;
+            return ret;
+        },
+        __wbg_static_accessor_GLOBAL_THIS_6614f2f4998e3c4c: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_GLOBAL_d8e8a2fefe80bc1d: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_SELF_e29eaf7c465526b1: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_WINDOW_66e7ca3eef30585a: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_status_3a65028f4384d918: function(arg0) {
+            const ret = arg0.status;
+            return ret;
+        },
+        __wbg_stringify_c585a2d825a78689: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_subarray_f36da54ffa7114f5: function(arg0, arg1, arg2) {
+            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
+        __wbg_text_96bbece7b1823162: function() { return handleError(function (arg0) {
+            const ret = arg0.text();
+            return ret;
+        }, arguments); },
+        __wbg_then_1170ade08ea65bc7: function(arg0, arg1, arg2) {
+            const ret = arg0.then(arg1, arg2);
+            return ret;
+        },
+        __wbg_then_fdc17de424bf508a: function(arg0, arg1) {
+            const ret = arg0.then(arg1);
+            return ret;
+        },
+        __wbg_toString_a22faf60361782a5: function(arg0) {
+            const ret = arg0.toString();
+            return ret;
+        },
+        __wbg_url_f73e822379c5f00c: function(arg0, arg1) {
+            const ret = arg1.url;
+            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);
+        },
+        __wbg_value_414b42ce7b3eca22: function(arg0) {
+            const ret = arg0.value;
+            return ret;
+        },
+        __wbg_versions_276b2795b1c6a219: function(arg0) {
+            const ret = arg0.versions;
+            return ret;
+        },
+        __wbg_view_3120c63593e25b87: function(arg0) {
+            const ret = arg0.view;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_warn_b4702bd741d1b96e: function(arg0, arg1, arg2, arg3) {
+            console.warn(arg0, arg1, arg2, arg3);
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 198, function: Function { arguments: [], shim_idx: 199, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h58cb744c6dbe38df, wasm_bindgen__convert__closures_____invoke__h87777aac4a35a114);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 202, function: Function { arguments: [Externref], shim_idx: 100, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h5fe3bbd9cd01a9bd, wasm_bindgen__convert__closures_____invoke__h466de037074efd73);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 202, function: Function { arguments: [Externref], shim_idx: 203, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h5fe3bbd9cd01a9bd, wasm_bindgen__convert__closures_____invoke__h94cf5291c982569e);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000004: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000005: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000008: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000009: 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;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./pubky_bg.js": import0,
+    };
+}
+
+function wasm_bindgen__convert__closures_____invoke__h87777aac4a35a114(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h87777aac4a35a114(arg0, arg1);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h94cf5291c982569e(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h94cf5291c982569e(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h466de037074efd73(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h466de037074efd73(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
     }
 }
-if (Symbol.dispose) Signer.prototype[Symbol.dispose] = Signer.prototype.free;
 
-exports.Signer = Signer;
+function wasm_bindgen__convert__closures_____invoke__h2ffe4d8ada5ad683(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h2ffe4d8ada5ad683(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"];
+
+
+const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+const AuthFlowFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_authflow_free(ptr >>> 0, 1));
+const AuthFlowKindFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_authflowkind_free(ptr >>> 0, 1));
+const AuthTokenFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_authtoken_free(ptr >>> 0, 1));
+const ClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_client_free(ptr >>> 0, 1));
+const EventFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_event_free(ptr >>> 0, 1));
+const EventStreamBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_eventstreambuilder_free(ptr >>> 0, 1));
+const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
+const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));
+const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));
+const KeypairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_keypair_free(ptr >>> 0, 1));
+const PkdnsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pkdns_free(ptr >>> 0, 1));
+const PubkyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pubky_free(ptr >>> 0, 1));
+const PubkyResourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pubkyresource_free(ptr >>> 0, 1));
+const PublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_publickey_free(ptr >>> 0, 1));
+const PublicStorageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_publicstorage_free(ptr >>> 0, 1));
+const SeedExportDeepLinkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_seedexportdeeplink_free(ptr >>> 0, 1));
+const SessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_session_free(ptr >>> 0, 1));
+const SessionInfoFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sessioninfo_free(ptr >>> 0, 1));
+const SessionStorageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sessionstorage_free(ptr >>> 0, 1));
+const SignerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signer_free(ptr >>> 0, 1));
 const SigninDeepLinkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_signindeeplink_free(ptr >>> 0, 1));
+const SignupDeepLinkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signupdeeplink_free(ptr >>> 0, 1));
 
-class SigninDeepLink {
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
 
-    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;
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
     }
+}
 
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SigninDeepLinkFinalization.unregister(this);
-        return ptr;
-    }
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
 
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_signindeeplink_free(ptr, 0);
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
     }
-    /**
-     * @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]);
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
         }
-        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);
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
         }
     }
-    /**
-     * @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);
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
         }
+        debug += ']';
+        return debug;
     }
-    /**
-     * @returns {Uint8Array}
-     */
-    get secret() {
-        const ret = wasm.signindeeplink_secret(this.__wbg_ptr);
-        return ret;
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
     }
-    /**
-     * @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 (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
         }
     }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
 }
-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));
+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;
+}
 
-class SignupDeepLink {
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
 
-    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;
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
     }
+    return cachedDataViewMemory0;
+}
 
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SignupDeepLinkFinalization.unregister(this);
-        return ptr;
-    }
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
 
-    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]);
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
     }
-    /**
-     * @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);
-        }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
     }
-    /**
-     * @returns {string}
-     */
-    get baseRelayUrl() {
-        let deferred1_0;
-        let deferred1_1;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+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 {
-            const ret = wasm.signupdeeplink_baseRelayUrl(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
+            return f(a, state.b, ...args);
         } 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);
+            state.a = a;
+            real._wbg_cb_unref();
         }
-        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);
+    };
+    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;
 }
-if (Symbol.dispose) SignupDeepLink.prototype[Symbol.dispose] = SignupDeepLink.prototype.free;
 
-exports.SignupDeepLink = SignupDeepLink;
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 
-exports.__wbg_Error_e83987f665cf5504 = function(arg0, arg1) {
-    const ret = Error(getStringFromWasm0(arg0, arg1));
-    return ret;
-};
-
-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;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-};
-
-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;
-};
-
-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);
-};
-
-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) };
-
-exports.__wbg_arrayBuffer_b375eccb84b4ddf3 = function() { return handleError(function (arg0) {
-    const ret = arg0.arrayBuffer();
-    return ret;
-}, arguments) };
-
-exports.__wbg_authtoken_new = function(arg0) {
-    const ret = AuthToken.__wrap(arg0);
-    return ret;
-};
-
-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;
-};
-
-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) };
-
-exports.__wbg_call_e762c39fa8ea36bf = function() { return handleError(function (arg0, arg1) {
-    const ret = arg0.call(arg1);
-    return ret;
-}, arguments) };
-
-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;
-};
-
-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;
-};
-
-exports.__wbg_debug_e55e1461940eb14d = function(arg0, arg1, arg2, arg3) {
-    console.debug(arg0, arg1, arg2, arg3);
-};
-
-exports.__wbg_done_2042aa2670fb1db1 = function(arg0) {
-    const ret = arg0.done;
-    return ret;
-};
-
-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;
-};
-
-exports.__wbg_error_d8b22cf4e59a6791 = function(arg0, arg1, arg2, arg3) {
-    console.error(arg0, arg1, arg2, arg3);
-};
-
-exports.__wbg_fetch_013f0d75d4254327 = function(arg0) {
-    const ret = fetch(arg0);
-    return ret;
-};
-
-exports.__wbg_fetch_74a3e84ebd2c9a0e = function(arg0) {
-    const ret = fetch(arg0);
-    return ret;
-};
-
-exports.__wbg_fetch_f8ba0e29a9d6de0d = function(arg0, arg1) {
-    const ret = arg0.fetch(arg1);
-    return ret;
-};
-
-exports.__wbg_from_a4ad7cbddd0d7135 = function(arg0) {
-    const ret = Array.from(arg0);
-    return ret;
-};
-
-exports.__wbg_getRandomValues_1c61fac11405ffdc = function() { return handleError(function (arg0, arg1) {
-    globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
-}, arguments) };
-
-exports.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
-    arg0.getRandomValues(arg1);
-}, arguments) };
-
-exports.__wbg_getReader_48e00749fe3f6089 = function() { return handleError(function (arg0) {
-    const ret = arg0.getReader();
-    return ret;
-}, arguments) };
-
-exports.__wbg_get_7bed016f185add81 = function(arg0, arg1) {
-    const ret = arg0[arg1 >>> 0];
-    return ret;
-};
-
-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) };
-
-exports.__wbg_headers_b87d7eaba61c3278 = function(arg0) {
-    const ret = arg0.headers;
-    return ret;
-};
-
-exports.__wbg_info_68cd5b51ef7e5137 = function(arg0, arg1, arg2, arg3) {
-    console.info(arg0, arg1, arg2, arg3);
-};
-
-exports.__wbg_instanceof_ArrayBuffer_70beb1189ca63b38 = function(arg0) {
-    let result;
-    try {
-        result = arg0 instanceof ArrayBuffer;
-    } catch (_) {
-        result = false;
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
     }
-    const ret = result;
-    return ret;
-};
 
-exports.__wbg_instanceof_Error_a944ec10920129e2 = function(arg0) {
-    let result;
-    try {
-        result = arg0 instanceof Error;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-};
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
 
-exports.__wbg_instanceof_Headers_e1daf97ed6a469e9 = function(arg0) {
-    let result;
-    try {
-        result = arg0 instanceof Headers;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-};
+    const mem = getUint8ArrayMemory0();
 
-exports.__wbg_instanceof_Map_8579b5e2ab5437c7 = function(arg0) {
-    let result;
-    try {
-        result = arg0 instanceof Map;
-    } catch (_) {
-        result = false;
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
     }
-    const ret = result;
-    return ret;
-};
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
 
-exports.__wbg_instanceof_Response_f4f3e87e07f3135c = function(arg0) {
-    let result;
-    try {
-        result = arg0 instanceof Response;
-    } catch (_) {
-        result = false;
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
     }
-    const ret = result;
-    return ret;
-};
 
-exports.__wbg_instanceof_Uint8Array_20c8e73002f7af98 = function(arg0) {
-    let result;
-    try {
-        result = arg0 instanceof Uint8Array;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-};
-
-exports.__wbg_isArray_96e0af9891d0945d = function(arg0) {
-    const ret = Array.isArray(arg0);
-    return ret;
-};
-
-exports.__wbg_isSafeInteger_d216eda7911dde36 = function(arg0) {
-    const ret = Number.isSafeInteger(arg0);
-    return ret;
-};
-
-exports.__wbg_iterator_e5822695327a3c39 = function() {
-    const ret = Symbol.iterator;
-    return ret;
-};
-
-exports.__wbg_length_69bca3cb64fc8748 = function(arg0) {
-    const ret = arg0.length;
-    return ret;
-};
-
-exports.__wbg_length_cdd215e10d9dd507 = function(arg0) {
-    const ret = arg0.length;
-    return ret;
-};
-
-exports.__wbg_log_45eb3a49e7cdcb64 = function(arg0, arg1, arg2, arg3) {
-    console.log(arg0, arg1, arg2, arg3);
-};
-
-exports.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
-    const ret = arg0.msCrypto;
-    return ret;
-};
-
-exports.__wbg_new_1acc0b6eea89d040 = function() {
-    const ret = new Object();
-    return ret;
-};
-
-exports.__wbg_new_2531773dac38ebb3 = function() { return handleError(function () {
-    const ret = new AbortController();
-    return ret;
-}, arguments) };
-
-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 wasm_bindgen__convert__closures_____invoke__h07d45d2c9c5e1bbe(a, state0.b, arg0, arg1);
-            } finally {
-                state0.a = a;
-            }
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
         };
-        const ret = new Promise(cb0);
-        return ret;
-    } finally {
-        state0.a = state0.b = 0;
-    }
-};
-
-exports.__wbg_new_5a79be3ab53b8aa5 = function(arg0) {
-    const ret = new Uint8Array(arg0);
-    return ret;
-};
-
-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;
-};
-
-exports.__wbg_new_no_args_ee98eee5275000a4 = function(arg0, arg1) {
-    const ret = new Function(getStringFromWasm0(arg0, arg1));
-    return ret;
-};
-
-exports.__wbg_new_with_byte_offset_and_length_46e3e6a5e9f9e89b = function(arg0, arg1, arg2) {
-    const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
-    return ret;
-};
-
-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;
-};
-
-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) };
-
-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) };
-
-exports.__wbg_next_020810e0ae8ebcb0 = function() { return handleError(function (arg0) {
-    const ret = arg0.next();
-    return ret;
-}, arguments) };
-
-exports.__wbg_next_2c826fe5dfec6b6a = function(arg0) {
-    const ret = arg0.next;
-    return ret;
-};
-
-exports.__wbg_node_905d3e251edff8a2 = function(arg0) {
-    const ret = arg0.node;
-    return ret;
-};
-
-exports.__wbg_now_2c95c9de01293173 = function(arg0) {
-    const ret = arg0.now();
-    return ret;
-};
-
-exports.__wbg_now_793306c526e2e3b6 = function() {
-    const ret = Date.now();
-    return ret;
-};
-
-exports.__wbg_parse_2a704d6b78abb2b8 = function() { return handleError(function (arg0, arg1) {
-    const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
-    return ret;
-}, arguments) };
-
-exports.__wbg_performance_7a3ffd0b17f663ad = function(arg0) {
-    const ret = arg0.performance;
-    return ret;
-};
-
-exports.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
-    const ret = arg0.process;
-    return ret;
-};
-
-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;
-};
-
-exports.__wbg_queueMicrotask_34d692c25c47d05b = function(arg0) {
-    const ret = arg0.queueMicrotask;
-    return ret;
-};
-
-exports.__wbg_queueMicrotask_9d76cacb20c84d58 = function(arg0) {
-    queueMicrotask(arg0);
-};
-
-exports.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
-    arg0.randomFillSync(arg1);
-}, arguments) };
-
-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) };
-
-exports.__wbg_resolve_caf97c30b83f7053 = function(arg0) {
-    const ret = Promise.resolve(arg0);
-    return ret;
-};
-
-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;
-};
-
-exports.__wbg_setTimeout_7bb3429662ab1e70 = function(arg0, arg1) {
-    const ret = setTimeout(arg0, arg1);
-    return ret;
-};
-
-exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
-    arg0[arg1] = arg2;
-};
-
-exports.__wbg_set_8b342d8cd9d2a02c = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-    arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
-}, arguments) };
-
-exports.__wbg_set_907fb406c34a251d = function(arg0, arg1, arg2) {
-    const ret = arg0.set(arg1, arg2);
-    return ret;
-};
-
-exports.__wbg_set_9e6516df7b7d0f19 = function(arg0, arg1, arg2) {
-    arg0.set(getArrayU8FromWasm0(arg1, arg2));
-};
-
-exports.__wbg_set_body_3c365989753d61f4 = function(arg0, arg1) {
-    arg0.body = 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];
-};
-
-exports.__wbg_set_credentials_f621cd2d85c0c228 = function(arg0, arg1) {
-    arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
-};
-
-exports.__wbg_set_headers_107379072e02fee5 = function(arg0, arg1) {
-    arg0.headers = arg1;
-};
-
-exports.__wbg_set_headers_6926da238cd32ee4 = function(arg0, arg1) {
-    arg0.headers = arg1;
-};
-
-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);
-};
-
-exports.__wbg_set_mode_52ef73cfa79639cb = function(arg0, arg1) {
-    arg0.mode = __wbindgen_enum_RequestMode[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;
-};
-
-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;
-};
-
-exports.__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e = function() {
-    const ret = typeof global === 'undefined' ? null : global;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-};
-
-exports.__wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac = function() {
-    const ret = typeof globalThis === 'undefined' ? null : globalThis;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-};
-
-exports.__wbg_static_accessor_SELF_6fdf4b64710cc91b = function() {
-    const ret = typeof self === 'undefined' ? null : self;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-};
-
-exports.__wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2 = function() {
-    const ret = typeof window === 'undefined' ? null : window;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-};
-
-exports.__wbg_status_de7eed5a7a5bfd5d = function(arg0) {
-    const ret = arg0.status;
-    return ret;
-};
-
-exports.__wbg_stringify_b5fb28f6465d9c3e = function() { return handleError(function (arg0) {
-    const ret = JSON.stringify(arg0);
-    return ret;
-}, arguments) };
-
-exports.__wbg_subarray_480600f3d6a9f26c = function(arg0, arg1, arg2) {
-    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
-    return ret;
-};
-
-exports.__wbg_text_dc33c15c17bdfb52 = function() { return handleError(function (arg0) {
-    const ret = arg0.text();
-    return ret;
-}, arguments) };
-
-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;
-};
-
-exports.__wbg_toString_8eec07f6f4c057e4 = function(arg0) {
-    const ret = arg0.toString();
-    return ret;
-};
-
-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;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-};
-
-exports.__wbg_value_692627309814bb8c = function(arg0) {
-    const ret = arg0.value;
-    return ret;
-};
-
-exports.__wbg_versions_c01dfd4722a88165 = function(arg0) {
-    const ret = arg0.versions;
-    return ret;
-};
-
-exports.__wbg_view_f6c15ac9fed63bbd = function(arg0) {
-    const ret = arg0.view;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-};
-
-exports.__wbg_warn_8f5b5437666d0885 = function(arg0, arg1, arg2, arg3) {
-    console.warn(arg0, arg1, arg2, arg3);
-};
-
-exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
-    // Cast intrinsic for `Ref(String) -> Externref`.
-    const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
-};
-
-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;
-};
-
-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;
-};
-
-exports.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
-    // Cast intrinsic for `U64 -> Externref`.
-    const ret = BigInt.asUintN(64, arg0);
-    return ret;
-};
-
-exports.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
-    // Cast intrinsic for `I64 -> Externref`.
-    const ret = arg0;
-    return ret;
-};
-
-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;
-};
-
-exports.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
-    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-    const ret = getArrayU8FromWasm0(arg0, arg1);
-    return ret;
-};
-
-exports.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
-    // Cast intrinsic for `F64 -> Externref`.
-    const ret = arg0;
-    return ret;
-};
-
-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);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
-    ;
-};
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
 
 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;
-
+let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
 wasm.__wbindgen_start();
-