@bounded-sh/core 0.0.42 → 0.0.44

package/dist/index.js

@@ -51,6 +51,10 @@ let clientConfig = {
     isServer: false,
 };
 let isInitialized = false;
+// Callers awaiting getConfig() before init() completes. Resolved synchronously
+// by init() — the previous 50ms setInterval poll added up to 50ms of latency
+// to the first SDK operation after init for no reason.
+let initWaiters = [];
 const BOUNDED_NETWORKS = {
     'bounded-staging': {
         wsApiUrl: 'wss://realtime-staging.bounded.sh',
@@ -119,23 +123,17 @@ function init(newConfig) {
         const preset = newConfig.network ? BOUNDED_NETWORKS[newConfig.network] : {};
         clientConfig = Object.assign(Object.assign(Object.assign({}, clientConfig), preset), newConfig);
         isInitialized = true;
+        const waiters = initWaiters;
+        initWaiters = [];
+        for (const wake of waiters)
+            wake();
         resolve();
     });
 }
 function waitForInitialization() {
-    return new Promise((resolve) => {
-        if (isInitialized) {
-            resolve();
-        }
-        else {
-            const interval = setInterval(() => {
-                if (isInitialized) {
-                    clearInterval(interval);
-                    resolve();
-                }
-            }, 50);
-        }
-    });
+    if (isInitialized)
+        return Promise.resolve();
+    return new Promise((resolve) => { initWaiters.push(resolve); });
 }
 async function getConfig() {
     await waitForInitialization();
@@ -2821,8 +2819,24 @@ async function genAuthNonce() {
 // stamps an is_anonymous claim. Without this a guest would be indistinguishable
 // from 'phantom' and couldn't be gated or flagged.
 const SIGNATURE_AUTH_METHODS = new Set(['phantom', 'mobile-wallet-adapter', 'guest']);
-async function createSessionWithSignature(address, message, signature) {
-    var _a, _b;
+// Maps a client authMethod to the /session issuer's signature discriminator when
+// they differ. EVM WALLET LOGIN (config.authMethod 'evm-wallet') exchanges a SIWE
+// (EIP-4361 personal_sign, secp256k1) signature, which the bounded-auth issuer
+// routes on authMethod:"siwe" (index.ts /session → parseSiweMessage/recoverSiweSigner)
+// and mints under custom:evmWalletAddress. The EVM provider also passes 'siwe'
+// explicitly (authMethodOverride), so this map is the belt-and-suspenders path.
+const SESSION_METHOD_ALIASES = { 'evm-wallet': 'siwe' };
+/**
+ * Exchange a wallet signature for a Bounded session at the /session issuer.
+ *
+ * @param authMethodOverride the exact /session discriminator to send (e.g. 'siwe'
+ *   for the SIWE/EVM path). When omitted the method is derived from config: an
+ *   aliased method (evm-wallet → siwe) maps through SESSION_METHOD_ALIASES, a
+ *   Solana wallet/guest method passes through verbatim, and anything else
+ *   defaults to the canonical 'phantom' the issuer accepts for a signature.
+ */
+async function createSessionWithSignature(address, message, signature, authMethodOverride) {
+    var _a, _b, _c;
     const client = await getAxiosAuthClient();
     const config = await getConfig();
     const appId = config.appId;
@@ -2831,7 +2845,7 @@ async function createSessionWithSignature(address, message, signature) {
     // canonical Solana wallet method 'phantom' that every /session issuer accepts
     // for a signature exchange. This is what makes the server SDK + guest device
     // keypair work under the email-default config.
-    const authMethod = SIGNATURE_AUTH_METHODS.has(config.authMethod) ? config.authMethod : 'phantom';
+    const authMethod = (_a = authMethodOverride !== null && authMethodOverride !== void 0 ? authMethodOverride : SESSION_METHOD_ALIASES[config.authMethod]) !== null && _a !== void 0 ? _a : (SIGNATURE_AUTH_METHODS.has(config.authMethod) ? config.authMethod : 'phantom');
     try {
         const response = await client.post('/session', {
             appId,
@@ -2846,11 +2860,11 @@ async function createSessionWithSignature(address, message, signature) {
         // Surface the issuer's actionable message (e.g. "Anonymous auth is not enabled for
         // this app. Add \"auth\": { \"anonymous\": true } to policy.json and redeploy.")
         // instead of axios's generic "Request failed with status code 403".
-        const d = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.data;
+        const d = (_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.data;
         if (d && (d.message || d.error)) {
             const e = new Error(String(d.message || d.error));
             e.code = d.error;
-            e.status = (_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.status;
+            e.status = (_c = err === null || err === void 0 ? void 0 : err.response) === null || _c === void 0 ? void 0 : _c.status;
             e.hint = d.hint;
             throw e;
         }
@@ -3625,12 +3639,13 @@ const NO_AMBIENT_SERVER_SESSION = "Server sessions are not process-global. Use c
 /* SESSION MANAGER                                                     */
 /* ------------------------------------------------------------------ */
 class ServerSessionManager {
-    constructor(keypair) {
+    constructor(keypair, sessionFactory) {
         /* Private cache (lives for the life of the instance) */
         this.session = null;
         /* Coalesce concurrent getSession() calls into a single in-flight request */
         this.pendingSession = null;
         this.keypair = keypair !== null && keypair !== void 0 ? keypair : null;
+        this.sessionFactory = sessionFactory !== null && sessionFactory !== void 0 ? sessionFactory : null;
     }
     /**
      * Create a session manager for a specific keypair.
@@ -3639,10 +3654,30 @@ class ServerSessionManager {
     static forKeypair(keypair) {
         return new ServerSessionManager(keypair);
     }
+    /**
+     * Create an isolated server session manager for a non-Solana signer (currently
+     * EVM/SIWE). The factory must perform the signature exchange and return the
+     * canonical signer address with its tokens; no signer state becomes global.
+     */
+    static forSessionFactory(factory) {
+        if (typeof factory !== 'function')
+            throw new Error('A server session factory is required');
+        return new ServerSessionManager(undefined, factory);
+    }
     /* ---------------------------------------------- *
      * Session creation (instance method)
      * ---------------------------------------------- */
     async createSession() {
+        if (this.sessionFactory) {
+            const session = await this.sessionFactory();
+            if (!session || typeof session.address !== 'string' || !session.address ||
+                typeof session.idToken !== 'string' || !session.idToken ||
+                typeof session.accessToken !== 'string' || !session.accessToken ||
+                typeof session.refreshToken !== 'string' || !session.refreshToken) {
+                throw new Error('Server signer session factory returned an invalid session');
+            }
+            return session;
+        }
         if (!this.keypair) {
             throw new Error(NO_AMBIENT_SERVER_SESSION);
         }
@@ -3746,6 +3781,133 @@ function decodeBase64Url(input) {
     return safeAtob(b64);
 }
 
+// evm-utils.ts — the EVM twin of sol/sol-utils.ts's genSolanaMessage. It builds
+// the canonical EIP-4361 (Sign-In with Ethereum, SIWE) prompt the bounded-auth
+// issuer verifies, and normalizes EVM addresses to the single canonical form the
+// identity layer matches on.
+//
+// The SIWE message MUST match bounded-auth's parser byte-for-byte
+// (packages/cdk/cloudflare/bounded-auth/src/verify-siwe.ts → parseSiweMessage):
+//   <domain> wants you to sign in with your Ethereum account:
+//   <address>
+//   <blank>
+//   <statement>
+//   <blank>
+//   URI: <uri>
+//   Version: 1
+//   Chain ID: <chainId>
+//   Nonce: <nonce>
+//   Issued At: <ISO8601>
+//   Expiration Time: <ISO8601>
+//   Resources:
+//   - bounded:app:<appId>
+//
+// Bindings the verifier enforces (so we produce them exactly): the address is
+// lowercased (identity match is case-sensitive, so lowercase-at-boundary is
+// mandatory), the single `bounded:app:<appId>` resource binds the signature to
+// THIS app (a signature for one app must not mint a session for another — the
+// SIWE analog of genSolanaMessage's `App ID:` line), and Expiration Time is
+// REQUIRED and must fall within the issuer's 10-minute max validity window.
+/** Default statement — kept identical to genSolanaMessage's for a consistent prompt. */
+const DEFAULT_STATEMENT = 'Sign this message to authenticate with our application.';
+/** Match bounded-auth's MAX_AUTH_WINDOW_MS (10 min); we default to a 5-min window. */
+const DEFAULT_VALIDITY_MS = 5 * 60 * 1000;
+/**
+ * Build the canonical EIP-4361 SIWE message the bounded-auth issuer verifies.
+ *
+ * @param address  the connected EVM account (lowercased into the prompt).
+ * @param nonce    single-use nonce from genAuthNonce().
+ * @param appId    the target app id (bound as the sole `bounded:app:<appId>` resource).
+ * @param domain   RFC-3986 authority of the requesting site (e.g. window.location.host).
+ * @param uri      the requesting URI; its origin is bound to the domain and actual browser Origin.
+ */
+function genSiweMessage(address, nonce, appId, domain, uri, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const addr = normalizeEvmAddress(address);
+    if (!addr)
+        throw new Error('SIWE address must be a 20-byte 0x-prefixed EVM address');
+    const statement = (_a = options.statement) !== null && _a !== void 0 ? _a : DEFAULT_STATEMENT;
+    const version = (_b = options.version) !== null && _b !== void 0 ? _b : '1';
+    const chainId = (_c = options.chainId) !== null && _c !== void 0 ? _c : 1;
+    if (statement !== DEFAULT_STATEMENT)
+        throw new Error('SIWE statement must use the canonical Bounded authentication text');
+    if (version !== '1')
+        throw new Error('SIWE version must be 1');
+    if (!Number.isSafeInteger(chainId) || chainId <= 0)
+        throw new Error('SIWE chainId must be a positive safe integer');
+    if (!/^[A-Za-z0-9]{8,}$/.test(nonce))
+        throw new Error('SIWE nonce must be at least 8 alphanumeric characters');
+    if (!appId || /[\r\n]/.test(appId))
+        throw new Error('SIWE appId is required and must be single-line');
+    if (!domain || domain !== domain.trim() || /[\s/@?#\\]/.test(domain))
+        throw new Error('SIWE domain must be an RFC-3986 authority');
+    try {
+        const parsedAuthority = new URL(`https://${domain}`);
+        if (parsedAuthority.username || parsedAuthority.password || parsedAuthority.pathname !== '/' ||
+            parsedAuthority.search || parsedAuthority.hash || parsedAuthority.host.toLowerCase() !== domain) {
+            throw new Error('non-canonical authority');
+        }
+    }
+    catch (_f) {
+        throw new Error('SIWE domain must be a canonical lowercase RFC-3986 authority');
+    }
+    let parsedUri;
+    try {
+        parsedUri = new URL(uri);
+    }
+    catch (_g) {
+        throw new Error('SIWE URI must be an absolute URL');
+    }
+    const local = parsedUri.hostname === 'localhost' || parsedUri.hostname === '127.0.0.1' || parsedUri.hostname === '[::1]';
+    if (parsedUri.protocol !== 'https:' && !(local && parsedUri.protocol === 'http:')) {
+        throw new Error('SIWE URI must use HTTPS (HTTP is allowed only for localhost)');
+    }
+    if (parsedUri.username || parsedUri.password || parsedUri.hash || parsedUri.host.toLowerCase() !== domain.toLowerCase()) {
+        throw new Error('SIWE URI authority must match the SIWE domain');
+    }
+    const issuedAtDate = (_d = options.issuedAt) !== null && _d !== void 0 ? _d : new Date();
+    const expirationDate = (_e = options.expirationTime) !== null && _e !== void 0 ? _e : new Date(issuedAtDate.getTime() + DEFAULT_VALIDITY_MS);
+    if (!Number.isFinite(issuedAtDate.getTime()) || !Number.isFinite(expirationDate.getTime()) || expirationDate <= issuedAtDate) {
+        throw new Error('SIWE validity window is invalid');
+    }
+    if (expirationDate.getTime() - issuedAtDate.getTime() > 10 * 60 * 1000) {
+        throw new Error('SIWE validity window exceeds 10 minutes');
+    }
+    const issuedAt = issuedAtDate.toISOString();
+    const expirationTime = expirationDate.toISOString();
+    return (`${domain} wants you to sign in with your Ethereum account:\n${addr}\n\n` +
+        `${statement}\n\n` +
+        `URI: ${parsedUri.toString()}\n` +
+        `Version: ${version}\n` +
+        `Chain ID: ${chainId}\n` +
+        `Nonce: ${nonce}\n` +
+        `Issued At: ${issuedAt}\n` +
+        `Expiration Time: ${expirationTime}\n` +
+        `Resources:\n` +
+        `- bounded:app:${appId}`);
+}
+/**
+ * Lowercase an EVM address to the canonical identity form. EVM addresses are
+ * case-insensitive on-chain but the identity layer (@user.evmAddress) matches
+ * case-sensitively, so every boundary normalizes to lowercase. Does not validate
+ * shape — use normalizeEvmAddress() when the input is untrusted.
+ */
+function toLowerEvmAddress(address) {
+    return address.trim().toLowerCase();
+}
+/**
+ * Normalize an untrusted EVM address to canonical lowercase 0x-hex, or null when
+ * it isn't a well-formed 20-byte hex address. Mirrors the realtime-worker's
+ * normalizeEvmAddress (auth.ts) EXACTLY so a client-derived @user.evmAddress and
+ * the server-authenticated one are byte-identical (fail-closed on malformed).
+ */
+function normalizeEvmAddress(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const v = raw.trim().toLowerCase();
+    return /^0x[0-9a-f]{40}$/.test(v) ? v : null;
+}
+
 async function createBearerToken(isServer) {
     if (isServer) {
         const sessionMgr = ServerSessionManager.instance;
@@ -3794,7 +3956,7 @@ async function getUserInfo(isServer) {
  * Returns all-null when the token can't be decoded (caller treats as no identity).
  */
 function deriveUserIdentityFromIdToken(idToken) {
-    const empty = { id: null, address: null, email: null };
+    const empty = { id: null, address: null, email: null, evmAddress: null };
     if (!idToken)
         return empty;
     try {
@@ -3807,14 +3969,25 @@ function deriveUserIdentityFromIdToken(idToken) {
             ? walletClaim
             : null;
         const userIdClaim = payload['custom:userId'];
-        const id = (typeof userIdClaim === 'string' && userIdClaim.length > 0)
+        let id = (typeof userIdClaim === 'string' && userIdClaim.length > 0)
             ? userIdClaim
             : null;
         const emailClaim = payload['email'];
         const email = (typeof emailClaim === 'string' && emailClaim.length > 0)
             ? emailClaim.toLowerCase()
             : null;
-        return { id, address, email };
+        // EVM wallet — carried on the `custom:evmWalletAddress` claim (an EVM login
+        // OMITS custom:walletAddress). Normalized to canonical lowercase 0x-hex the
+        // SAME way the realtime-worker does, so the client @user.evmAddress and the
+        // server-authenticated one are byte-identical (fail-closed on malformed).
+        const evmAddress = normalizeEvmAddress(payload['custom:evmWalletAddress']);
+        // A SIWE identity uses its EVM address as custom:userId. Normalize legacy
+        // mixed-case tokens at this boundary too so the principal and
+        // @user.evmAddress cannot diverge solely by hex casing. Opaque human-login
+        // ids remain byte-for-byte unchanged even when they have a linked wallet.
+        if (evmAddress && id && normalizeEvmAddress(id) === evmAddress)
+            id = evmAddress;
+        return { id, address, email, evmAddress };
     }
     catch (_a) {
         return empty;
@@ -4136,6 +4309,456 @@ async function makeApiRequest(method, urlPath, data, _overrides) {
     }
 }
 
+/**
+ * Selectors derived from the canonical BoundedRuntime signatures (BoundedTypes.sol):
+ *
+ *   cast sig 'setDocuments(string,(string[],bool,(string,uint8,uint8,bytes)[])[])'
+ *     => 0x0827b094
+ *   cast sig 'setDocumentsAttested(string,(string[],bool,(string,uint8,uint8,bytes)[])[],(bytes32,uint256,uint256,uint8,bytes32,bytes32))'
+ *     => 0x87b111c4
+ *
+ * Keep the signatures beside the constants: changing either Solidity tuple is an
+ * ABI break and must deliberately update these values and the Foundry goldens.
+ */
+const BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR = '0x0827b094';
+const BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR = '0x87b111c4';
+const SET_DOCUMENTS_SELECTOR = BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR.slice(2);
+const SET_DOCUMENTS_ATTESTED_SELECTOR = BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR.slice(2);
+const MAX_CALLDATA_BYTES = 1024 * 1024;
+const MAX_ARRAY_ITEMS = 2048;
+const BIGINT_ZERO = BigInt(0);
+const BIGINT_ONE = BigInt(1);
+const BIGINT_EIGHT = BigInt(8);
+const SECP256K1_N = BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');
+const SECP256K1_HALF_N = BigInt('0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0');
+function hexBytes(raw) {
+    if (typeof raw !== 'string' || !/^0x[0-9a-fA-F]*$/.test(raw) || raw.length % 2 !== 0) {
+        throw new Error('EVM transaction calldata must be even-length 0x hex');
+    }
+    const hex = raw.slice(2);
+    if (hex.length / 2 > MAX_CALLDATA_BYTES)
+        throw new Error('EVM transaction calldata exceeds the client safety limit');
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    return out;
+}
+class AbiReader {
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.maxRead = 0;
+        this.dynamicPayloadBytes = 0;
+        this.utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: false });
+    }
+    range(offset, length, label) {
+        if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset + length > this.bytes.length) {
+            throw new Error(`Malformed EVM setDocuments calldata (${label})`);
+        }
+        this.maxRead = Math.max(this.maxRead, offset + length);
+    }
+    word(offset, label) {
+        this.range(offset, 32, label);
+        let value = BIGINT_ZERO;
+        for (let i = 0; i < 32; i++)
+            value = (value << BIGINT_EIGHT) | BigInt(this.bytes[offset + i]);
+        return value;
+    }
+    numberWord(offset, label, max = Number.MAX_SAFE_INTEGER) {
+        const value = this.word(offset, label);
+        if (value > BigInt(max))
+            throw new Error(`Malformed EVM setDocuments calldata (${label} too large)`);
+        return Number(value);
+    }
+    offset(base, wordOffset, min, label) {
+        const relative = this.numberWord(wordOffset, `${label} offset`, this.bytes.length);
+        if (relative < min || relative % 32 !== 0)
+            throw new Error(`Malformed EVM setDocuments calldata (${label} offset)`);
+        const absolute = base + relative;
+        this.range(absolute, 0, label);
+        return absolute;
+    }
+    dynamicBytes(at, label) {
+        const length = this.numberWord(at, `${label} length`, MAX_CALLDATA_BYTES);
+        this.dynamicPayloadBytes += length;
+        // ABI offsets may alias. Cap the cumulative decoded payload so a malicious
+        // 1 MB tail referenced by thousands of fields cannot amplify into a
+        // multi-gigabyte allocation/UTF-8 decode in the wallet process.
+        if (this.dynamicPayloadBytes > MAX_CALLDATA_BYTES) {
+            throw new Error('Malformed EVM setDocuments calldata (dynamic payload amplification)');
+        }
+        const start = at + 32;
+        const padded = Math.ceil(length / 32) * 32;
+        this.range(start, padded, label);
+        for (let i = start + length; i < start + padded; i++) {
+            if (this.bytes[i] !== 0)
+                throw new Error(`Malformed EVM setDocuments calldata (${label} padding)`);
+        }
+        return this.bytes.slice(start, start + length);
+    }
+    dynamicEnd(at, label) {
+        const length = this.numberWord(at, `${label} length`, MAX_CALLDATA_BYTES);
+        const end = at + 32 + Math.ceil(length / 32) * 32;
+        this.range(at + 32, Math.ceil(length / 32) * 32, label);
+        return end;
+    }
+    string(at, label) {
+        try {
+            return this.utf8.decode(this.dynamicBytes(at, label));
+        }
+        catch (_a) {
+            throw new Error(`Malformed EVM setDocuments calldata (${label} utf8)`);
+        }
+    }
+    finish() {
+        if (this.maxRead !== this.bytes.length)
+            throw new Error('Malformed EVM setDocuments calldata (unreferenced trailing bytes)');
+    }
+}
+function assertCanonicalOffset(actual, expected, label) {
+    if (actual !== expected)
+        throw new Error(`Malformed EVM setDocuments calldata (${label} non-canonical offset)`);
+}
+function decodeStringArray(reader, at, label) {
+    const count = reader.numberWord(at, `${label} count`, MAX_ARRAY_ITEMS);
+    const head = at + 32;
+    const min = count * 32;
+    const out = [];
+    let expectedTail = head + min;
+    for (let i = 0; i < count; i++) {
+        const itemAt = reader.offset(head, head + i * 32, min, `${label}[${i}]`);
+        assertCanonicalOffset(itemAt, expectedTail, `${label}[${i}]`);
+        out.push(reader.string(itemAt, `${label}[${i}]`));
+        expectedTail = reader.dynamicEnd(itemAt, `${label}[${i}]`);
+    }
+    return { value: out, end: expectedTail };
+}
+function decodeFields(reader, at) {
+    const count = reader.numberWord(at, 'fields count', MAX_ARRAY_ITEMS);
+    const head = at + 32;
+    const min = count * 32;
+    const out = [];
+    let expectedTail = head + min;
+    for (let i = 0; i < count; i++) {
+        const tuple = reader.offset(head, head + i * 32, min, `field[${i}]`);
+        assertCanonicalOffset(tuple, expectedTail, `field[${i}]`);
+        const nameAt = reader.offset(tuple, tuple, 128, `field[${i}].name`);
+        assertCanonicalOffset(nameAt, tuple + 128, `field[${i}].name`);
+        const name = reader.string(nameAt, `field[${i}].name`);
+        const nameEnd = reader.dynamicEnd(nameAt, `field[${i}].name`);
+        const ftype = reader.numberWord(tuple + 32, `field[${i}].ftype`, 255);
+        const op = reader.numberWord(tuple + 64, `field[${i}].op`, 255);
+        const valueAt = reader.offset(tuple, tuple + 96, 128, `field[${i}].value`);
+        assertCanonicalOffset(valueAt, nameEnd, `field[${i}].value`);
+        const value = reader.dynamicBytes(valueAt, `field[${i}].value`);
+        expectedTail = reader.dynamicEnd(valueAt, `field[${i}].value`);
+        out.push({ name, ftype, op, value });
+    }
+    return { value: out, end: expectedTail };
+}
+function decodeRuntimeWrite(rawData) {
+    const bytes = hexBytes(rawData);
+    if (bytes.length < 68)
+        throw new Error('Malformed EVM setDocuments calldata');
+    const selector = Array.from(bytes.slice(0, 4)).map((b) => b.toString(16).padStart(2, '0')).join('');
+    const kind = selector === SET_DOCUMENTS_SELECTOR
+        ? 'setDocuments'
+        : selector === SET_DOCUMENTS_ATTESTED_SELECTOR
+            ? 'setDocumentsAttested'
+            : null;
+    if (!kind)
+        throw new Error('EVM transaction is not a supported BoundedRuntime document write');
+    const reader = new AbiReader(bytes);
+    reader.maxRead = 4;
+    const args = 4;
+    // ExternalCallAttestation is a fully-static six-word tuple and is therefore
+    // expanded inline into the top-level head: 2 dynamic offsets + 6 words.
+    const headBytes = kind === 'setDocumentsAttested' ? 256 : 64;
+    const appAt = reader.offset(args, args, headBytes, 'appId');
+    assertCanonicalOffset(appAt, args + headBytes, 'appId');
+    const opsAt = reader.offset(args, args + 32, headBytes, 'ops');
+    const appId = reader.string(appAt, 'appId');
+    const appEnd = reader.dynamicEnd(appAt, 'appId');
+    assertCanonicalOffset(opsAt, appEnd, 'ops');
+    const count = reader.numberWord(opsAt, 'ops count', MAX_ARRAY_ITEMS);
+    const head = opsAt + 32;
+    const min = count * 32;
+    const ops = [];
+    let expectedTail = head + min;
+    for (let i = 0; i < count; i++) {
+        const tuple = reader.offset(head, head + i * 32, min, `op[${i}]`);
+        assertCanonicalOffset(tuple, expectedTail, `op[${i}]`);
+        const pathAt = reader.offset(tuple, tuple, 96, `op[${i}].path`);
+        assertCanonicalOffset(pathAt, tuple + 96, `op[${i}].path`);
+        const deleteWord = reader.numberWord(tuple + 32, `op[${i}].isDelete`, 1);
+        const fieldsAt = reader.offset(tuple, tuple + 64, 96, `op[${i}].fields`);
+        const path = decodeStringArray(reader, pathAt, `op[${i}].path`);
+        assertCanonicalOffset(fieldsAt, path.end, `op[${i}].fields`);
+        const fields = decodeFields(reader, fieldsAt);
+        expectedTail = fields.end;
+        ops.push({
+            pathSegments: path.value,
+            isDelete: deleteWord === 1,
+            fields: fields.value,
+        });
+    }
+    let attestation;
+    if (kind === 'setDocumentsAttested') {
+        const callsHash = reader.word(args + 64, 'attestation.callsHash');
+        const nonce = reader.word(args + 96, 'attestation.nonce');
+        const deadline = reader.word(args + 128, 'attestation.deadline');
+        const v = reader.numberWord(args + 160, 'attestation.v', 255);
+        const r = reader.word(args + 192, 'attestation.r');
+        const s = reader.word(args + 224, 'attestation.s');
+        if (v !== 27 && v !== 28)
+            throw new Error('Malformed EVM setDocuments calldata (attestation.v must be 27 or 28)');
+        if (r === BIGINT_ZERO || r >= SECP256K1_N)
+            throw new Error('Malformed EVM setDocuments calldata (attestation.r is not canonical)');
+        if (s === BIGINT_ZERO || s > SECP256K1_HALF_N)
+            throw new Error('Malformed EVM setDocuments calldata (attestation.s is not canonical low-s)');
+        attestation = { callsHash, nonce, deadline, v, r, s };
+    }
+    if (expectedTail !== bytes.length)
+        throw new Error('Malformed EVM setDocuments calldata (unreferenced trailing bytes)');
+    reader.finish();
+    return Object.assign({ kind, appId, ops }, (attestation ? { attestation } : {}));
+}
+/**
+ * Fail closed unless calldata is a byte-for-byte canonical ABI encoding of one
+ * supported BoundedRuntime write. This is the defense used by direct signer
+ * surfaces; the higher-level write validator below additionally binds app/ops.
+ */
+function assertCanonicalBoundedRuntimeWriteCalldata(rawData) {
+    decodeRuntimeWrite(rawData);
+}
+const MAX_EVM_DOCUMENT_PATH_UTF8_BYTES = 1024;
+function canonicalUtf8ByteLength(value) {
+    let bytes = 0;
+    for (let i = 0; i < value.length; i++) {
+        const unit = value.charCodeAt(i);
+        if (unit <= 0x7f)
+            bytes += 1;
+        else if (unit <= 0x7ff)
+            bytes += 2;
+        else if (unit >= 0xd800 && unit <= 0xdbff) {
+            const low = value.charCodeAt(++i);
+            if (!(low >= 0xdc00 && low <= 0xdfff))
+                throw new Error(`Invalid EVM write path: ${value}`);
+            bytes += 4;
+        }
+        else if (unit >= 0xdc00 && unit <= 0xdfff) {
+            throw new Error(`Invalid EVM write path: ${value}`);
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+function normalizedPathSegments(path) {
+    if (typeof path !== 'string' || path.length === 0 ||
+        canonicalUtf8ByteLength(path) > MAX_EVM_DOCUMENT_PATH_UTF8_BYTES) {
+        throw new Error(`Invalid EVM write path: ${path}`);
+    }
+    const segments = path.split('/');
+    if (segments.length < 2 || segments.length % 2 !== 0 ||
+        segments[0].startsWith('__') ||
+        segments.some((s) => !s || s === '.' || s === '..' || /[\\\u0000-\u001f\u007f]/.test(s))) {
+        throw new Error(`Invalid EVM write path: ${path}`);
+    }
+    return segments;
+}
+function bytesBigInt(bytes, signed) {
+    if (bytes.length !== 32)
+        throw new Error('EVM field value is not one ABI word');
+    let value = BIGINT_ZERO;
+    for (const b of bytes)
+        value = (value << BIGINT_EIGHT) | BigInt(b);
+    if (signed && (value & (BIGINT_ONE << BigInt(255))) !== BIGINT_ZERO)
+        value -= BIGINT_ONE << BigInt(256);
+    return value;
+}
+function decodedAbiString(bytes) {
+    const reader = new AbiReader(bytes);
+    const at = reader.offset(0, 0, 32, 'field string');
+    const value = reader.string(at, 'field string');
+    reader.finish();
+    return value;
+}
+function assertSetValue(field, expected) {
+    if (field.op !== 0)
+        throw new Error(`EVM field ${field.name} changes the requested SET action`);
+    if (typeof expected === 'boolean') {
+        if (field.ftype !== 3 || bytesBigInt(field.value, false) !== (expected ? BIGINT_ONE : BIGINT_ZERO))
+            throw new Error(`EVM field ${field.name} value mismatch`);
+        return;
+    }
+    if (typeof expected === 'number') {
+        if (!Number.isFinite(expected))
+            throw new Error(`EVM field ${field.name} is not finite`);
+        if (Number.isInteger(expected)) {
+            if (!Number.isSafeInteger(expected)) {
+                throw new Error(`EVM field ${field.name} integer must be a safe number or canonical decimal string`);
+            }
+            const actual = field.ftype === 1 ? bytesBigInt(field.value, false) : field.ftype === 2 ? bytesBigInt(field.value, true) : null;
+            if (actual === null || actual !== BigInt(expected))
+                throw new Error(`EVM field ${field.name} value mismatch`);
+            return;
+        }
+        if (field.ftype !== 4 || decodedAbiString(field.value) !== expected.toString())
+            throw new Error(`EVM field ${field.name} value mismatch`);
+        return;
+    }
+    if (typeof expected === 'bigint') {
+        const actual = field.ftype === 1 ? bytesBigInt(field.value, false) : field.ftype === 2 ? bytesBigInt(field.value, true) : null;
+        if (actual === null || actual !== expected)
+            throw new Error(`EVM field ${field.name} value mismatch`);
+        return;
+    }
+    if (typeof expected === 'string') {
+        if (field.ftype === 4 && decodedAbiString(field.value) === expected)
+            return;
+        if ((field.ftype === 1 || field.ftype === 2) && expected.length <= 20 && /^-?(?:0|[1-9][0-9]*)$/.test(expected)) {
+            const exact = BigInt(expected);
+            if (exact >= BigInt(Number.MIN_SAFE_INTEGER) && exact <= BigInt(Number.MAX_SAFE_INTEGER)) {
+                throw new Error(`EVM field ${field.name} safe integer must be supplied as a number`);
+            }
+            const inRange = field.ftype === 1
+                ? exact >= BIGINT_ZERO && exact <= ((BIGINT_ONE << BigInt(64)) - BIGINT_ONE)
+                : exact >= -(BIGINT_ONE << BigInt(63)) && exact <= ((BIGINT_ONE << BigInt(63)) - BIGINT_ONE);
+            const actual = bytesBigInt(field.value, field.ftype === 2);
+            if (inRange && actual === exact)
+                return;
+            throw new Error(`EVM field ${field.name} value mismatch`);
+        }
+        if (field.ftype === 5 && normalizeEvmAddress(expected)) {
+            const word = field.value;
+            if (word.length === 32 && word.slice(0, 12).every((b) => b === 0)) {
+                const actual = `0x${Array.from(word.slice(12)).map((b) => b.toString(16).padStart(2, '0')).join('')}`;
+                if (actual === normalizeEvmAddress(expected))
+                    return;
+            }
+        }
+        throw new Error(`EVM field ${field.name} value mismatch`);
+    }
+    if (expected === undefined || expected === null) {
+        throw new Error(`EVM field ${field.name} cannot be represented safely on EVM; use a document delete or omit the field`);
+    }
+    const json = JSON.stringify(expected);
+    if (typeof json !== 'string' || field.ftype !== 4 || decodedAbiString(field.value) !== json) {
+        throw new Error(`EVM field ${field.name} value mismatch`);
+    }
+}
+function assertField(field, expected) {
+    if (expected === null) {
+        if (field.op !== 2 || field.ftype < 1 || field.ftype > 5 || field.value.length !== 0) {
+            throw new Error(`EVM field ${field.name} deletion mismatch`);
+        }
+        return;
+    }
+    if (expected && typeof expected === 'object' && !Array.isArray(expected)) {
+        const operation = expected.operation;
+        if (operation === 'increment') {
+            const delta = expected.value;
+            const actual = field.ftype === 1 || field.ftype === 2
+                ? bytesBigInt(field.value, true)
+                : null;
+            if (!Number.isSafeInteger(delta) || field.op !== 3 || actual === null || actual !== BigInt(delta)) {
+                throw new Error(`EVM field ${field.name} increment mismatch`);
+            }
+            return;
+        }
+        if (operation === 'time' && expected.value === 'now') {
+            if (field.op !== 4 || (field.ftype !== 1 && field.ftype !== 2) || field.value.length !== 0) {
+                throw new Error(`EVM field ${field.name} timestamp mismatch`);
+            }
+            return;
+        }
+    }
+    assertSetValue(field, expected);
+}
+function assertOp(decoded, path, document) {
+    const expectedSegments = normalizedPathSegments(path);
+    if (decoded.pathSegments.length !== expectedSegments.length || decoded.pathSegments.some((s, i) => s !== expectedSegments[i])) {
+        throw new Error(`EVM transaction path does not match requested write: ${path}`);
+    }
+    if (decoded.isDelete !== (document === null))
+        throw new Error(`EVM transaction action does not match requested write: ${path}`);
+    if (document === null) {
+        if (decoded.fields.length !== 0)
+            throw new Error(`EVM delete unexpectedly carries fields: ${path}`);
+        return;
+    }
+    if (!document || typeof document !== 'object' || Array.isArray(document))
+        throw new Error(`EVM document must be a plain object or null: ${path}`);
+    const expectedEntries = Object.entries(document);
+    if (expectedEntries.some(([name]) => name.startsWith('_')))
+        throw new Error(`Reserved EVM field reached transaction validation: ${path}`);
+    const expected = new Map(expectedEntries);
+    const seen = new Set();
+    for (const field of decoded.fields) {
+        if (!field.name || seen.has(field.name) || !expected.has(field.name))
+            throw new Error(`EVM transaction contains unexpected or duplicate field ${field.name}`);
+        seen.add(field.name);
+        assertField(field, expected.get(field.name));
+    }
+    const missing = [...expected.keys()].filter((name) => !seen.has(name));
+    if (missing.length > 0)
+        throw new Error(`EVM transaction omits requested fields: ${missing.join(', ')}`);
+}
+function zeroWei(raw) {
+    if (raw === undefined || raw === null || raw === '')
+        return true;
+    if (typeof raw !== 'string' && typeof raw !== 'number')
+        return false;
+    try {
+        return BigInt(raw) === BIGINT_ZERO;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/** Verify the untrusted 202 payload is exactly the governed write the app asked for. */
+function assertEvmTransactionMatchesWrite(transaction, context) {
+    var _a, _b;
+    if (!transaction || !Number.isSafeInteger(transaction.chainId) || transaction.chainId <= 0) {
+        throw new Error('EVM transaction chainId is required');
+    }
+    const chainId = transaction.chainId;
+    const policy = context.policy;
+    if (!policy)
+        throw new Error('EVM transaction signing requires an explicit runtime/chain policy');
+    if (policy.chainId !== undefined && policy.chainId !== chainId)
+        throw new Error(`EVM transaction chain ${chainId} does not match configured chain ${policy.chainId}`);
+    const expectedRuntime = (_b = (_a = policy.runtimeAddresses) === null || _a === void 0 ? void 0 : _a[String(chainId)]) !== null && _b !== void 0 ? _b : (policy.chainId === chainId ? policy.runtimeAddress : undefined);
+    const normalizedRuntime = normalizeEvmAddress(expectedRuntime);
+    if (!normalizedRuntime)
+        throw new Error(`No trusted BoundedRuntime address configured for EVM chain ${chainId}`);
+    if (normalizeEvmAddress(transaction.to) !== normalizedRuntime)
+        throw new Error('EVM transaction target is not the configured BoundedRuntime');
+    if (!zeroWei(transaction.value))
+        throw new Error('BoundedRuntime.setDocuments must not transfer native value');
+    if (transaction.nonce !== undefined)
+        throw new Error('Server-supplied EVM nonce is not accepted');
+    const decoded = decodeRuntimeWrite(transaction.data);
+    if (decoded.appId !== context.appId)
+        throw new Error('EVM transaction appId does not match configured appId');
+    if (decoded.ops.length !== context.documents.length)
+        throw new Error('EVM transaction operation count does not match requested writes');
+    // The worker's contract ABI groups upserts first and document deletes second.
+    const expectedOps = [
+        ...context.documents.filter((entry) => entry.document !== null),
+        ...context.documents.filter((entry) => entry.document === null),
+    ];
+    const paths = new Set();
+    for (let i = 0; i < expectedOps.length; i++) {
+        const expected = expectedOps[i];
+        const canonicalPath = normalizedPathSegments(expected.destinationPath).join('/');
+        if (paths.has(canonicalPath))
+            throw new Error(`Duplicate EVM write path is not allowed: ${canonicalPath}`);
+        paths.add(canonicalPath);
+        assertOp(decoded.ops[i], canonicalPath, expected.document);
+    }
+}
+
 var __rest$1 = (undefined && undefined.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -4272,6 +4895,21 @@ function hashForKey$1(value) {
     }
     return h.toString(36);
 }
+// Memoize the compact principal hash per exact credential string. Every read
+// hashed the entire (~1KB) bearer/idToken on every call; a session presents
+// the same handful of credentials for its lifetime. Bounded size — a rotation
+// simply inserts the new token and stale entries fall off on clear.
+const principalHashCache = new Map();
+function hashForKeyCached(value) {
+    const hit = principalHashCache.get(value);
+    if (hit !== undefined)
+        return hit;
+    const h = hashForKey$1(value);
+    if (principalHashCache.size >= 50)
+        principalHashCache.clear();
+    principalHashCache.set(value, h);
+    return h;
+}
 function hasAuthHeader(headers) {
     if (!headers)
         return false;
@@ -4282,10 +4920,10 @@ function authValueFromHeaders(headers) {
     return (headers === null || headers === void 0 ? void 0 : headers.Authorization) || (headers === null || headers === void 0 ? void 0 : headers.authorization) || '';
 }
 function principalFromAuthValue(authValue) {
-    return authValue ? `h${hashForKey$1(authValue)}` : null;
+    return authValue ? `h${hashForKeyCached(authValue)}` : null;
 }
 function principalFromIdToken$1(idToken) {
-    return idToken ? `t${hashForKey$1(idToken)}` : null;
+    return idToken ? `t${hashForKeyCached(idToken)}` : null;
 }
 function uncacheableReadKey(appId, scope) {
     uncacheableReadKeyCounter += 1;
@@ -5166,13 +5804,12 @@ async function runExpressionMany(many) {
  * collection's policy `delete` rule and broadcasts a delete to subscribers.
  */
 async function set(path, document, options) {
-    const result = await setMany([{ path, document }], options);
-    // Clear cache entries that might be affected by this update
-    clearCacheByPrefix(path);
-    return result;
+    // setMany already invalidates the read cache for the affected document and
+    // collection paths — no second sweep needed here.
+    return setMany([{ path, document }], options);
 }
 async function setMany(many, options) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     // Returns the data that was set, or undefined if the document was already set.
     try {
         const config = await getConfig();
@@ -5228,6 +5865,9 @@ async function setMany(many, options) {
             // the API did nothing and gave us the required info to run this transaction.
             const { transactions, offchainTransaction } = setResponse.data;
             // Handle offchain transaction flow (for 'offchain' protocol apps)
+            if (offchainTransaction && Array.isArray(transactions) && transactions.length > 0) {
+                throw new Error('Ambiguous write response mixes offchain and onchain transaction targets');
+            }
             if (offchainTransaction) {
                 const transactionResult = await handleOffchainTransaction(offchainTransaction, authProvider, options);
                 return Object.assign(Object.assign({}, documents.map(d => d.document)), { transactionId: transactionResult.signature, signedTransaction: transactionResult.signedTransaction });
@@ -5237,9 +5877,35 @@ async function setMany(many, options) {
                 throw new Error(`Expected exactly one on-chain transaction, received ${Array.isArray(transactions) ? transactions.length : 0}`);
             }
             const curTx = transactions[0];
+            const hasEvmTarget = (curTx === null || curTx === void 0 ? void 0 : curTx.evmTransaction) != null;
+            const hasSerializedSolanaTarget = (curTx === null || curTx === void 0 ? void 0 : curTx.serializedTransaction) != null;
+            const hasBuiltSolanaTarget = (curTx === null || curTx === void 0 ? void 0 : curTx.transactionArgs) != null || (curTx === null || curTx === void 0 ? void 0 : curTx.remainingAccounts) != null ||
+                (curTx === null || curTx === void 0 ? void 0 : curTx.idl) != null || (curTx === null || curTx === void 0 ? void 0 : curTx.txData) != null || (curTx === null || curTx === void 0 ? void 0 : curTx.preInstructions) != null;
+            if ((hasEvmTarget && (hasSerializedSolanaTarget || hasBuiltSolanaTarget)) ||
+                (hasSerializedSolanaTarget && hasBuiltSolanaTarget)) {
+                throw new Error('Ambiguous on-chain write response mixes EVM and/or Solana transaction target formats');
+            }
             let transactionResult;
             const expectedWritePaths = documents.map(d => d.destinationPath);
-            if (curTx.serializedTransaction) {
+            // EVM onchain write: the worker returns a PRE-BUILT EIP-1559 tx on
+            // `transactions[0].evmTransaction` (the EVM twin of Solana's pre-built
+            // `serializedTransaction`). WORKER 202 CONTRACT (field name + shape the
+            // worker side must emit to match):
+            //   { transactions: [ { evmTransaction: {
+            //       to, data, value?, chainId, gas?, maxFeePerGas?, maxPriorityFeePerGas?, nonce?
+            //   } } ] }
+            // We hand it to the EVM auth provider's runTransaction(evmTx, undefined, options)
+            // (eth_sendTransaction — the wallet signs + submits). syncItems below is
+            // identical to the Solana path.
+            if (curTx.evmTransaction) {
+                assertEvmTransactionMatchesWrite(curTx.evmTransaction, {
+                    appId: config.appId,
+                    documents,
+                    policy: (_k = (_j = (_h = options === null || options === void 0 ? void 0 : options._overrides) === null || _h === void 0 ? void 0 : _h._evmTransactionPolicy) !== null && _j !== void 0 ? _j : config.evmWalletConfig) !== null && _k !== void 0 ? _k : null,
+                });
+                transactionResult = await handleEvmTransaction(curTx.evmTransaction, authProvider, options);
+            }
+            else if (curTx.serializedTransaction) {
                 transactionResult = await handlePreBuiltTransaction(curTx, authProvider, options, expectedWritePaths);
             }
             else {
@@ -5263,7 +5929,7 @@ async function setMany(many, options) {
             else if (setResponse.data &&
                 typeof setResponse.data === 'object' &&
                 setResponse.data.success === true) {
-                const _h = setResponse.data, { success: _success } = _h, rest = __rest$1(_h, ["success"]);
+                const _l = setResponse.data, { success: _success } = _l, rest = __rest$1(_l, ["success"]);
                 return Object.assign(Object.assign(Object.assign({}, documents.map(d => d.document)), rest), { transactionId: null });
             }
             else {
@@ -5363,6 +6029,14 @@ async function setMany(many, options) {
         const transactionResult = await authProvider.runTransaction(undefined, solTransaction, options);
         return transactionResult;
     }
+    // EVM onchain write: hand the worker's pre-built EIP-1559 tx to the EVM auth
+    // provider, which eth_sendTransaction-s it (the wallet signs + submits in one
+    // step). Mirrors handlePreBuiltTransaction's shape but routes through the EVM
+    // slot of runTransaction (Solana slot undefined). shouldSubmitTx is honored by
+    // the provider itself.
+    async function handleEvmTransaction(evmTransaction, authProvider, options) {
+        return authProvider.runTransaction(evmTransaction, undefined, options);
+    }
     async function handlePreBuiltTransaction(tx, authProvider, options, expectedWritePaths) {
         var _a, _b, _c;
         const config = await getConfig();
@@ -6743,7 +7417,7 @@ function sendUnsubscribe(connection, subscriptionId) {
  *   the subscription onto, since a WS connection routes to a single DO.
  */
 async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e;
     const config = await getConfig();
     const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
     // Use explicit appId override if provided, otherwise fall back to config
@@ -6794,19 +7468,23 @@ async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
     const cachedEntry = cacheKey ? getResponseCacheEntry(cacheKey, identityToken) : undefined;
     // Check if we already have a subscription for this path+prompt+shape+limit+cursor+filter+sort
     let existingSubscription;
+    let specKey = '';
     try {
-        const shapeKey = subscriptionOptions.shape ? JSON.stringify(subscriptionOptions.shape) : '';
-        const filterKey = subscriptionOptions.filter ? JSON.stringify(subscriptionOptions.filter) : '';
-        const sortKey = subscriptionOptions.sort ? JSON.stringify(subscriptionOptions.sort) : '';
+        // Stringify THIS call's specs once; existing subscriptions carry their
+        // precomputed specKey, so the scan is a string compare per entry
+        // (previously each new subscribe re-stringified every existing
+        // subscription's shape/filter/sort — O(N²) with many live hooks).
+        specKey = JSON.stringify([
+            (_a = subscriptionOptions.shape) !== null && _a !== void 0 ? _a : null,
+            (_b = subscriptionOptions.filter) !== null && _b !== void 0 ? _b : null,
+            (_c = subscriptionOptions.sort) !== null && _c !== void 0 ? _c : null,
+        ]);
         for (const sub of connection.subscriptions.values()) {
-            const subShapeKey = sub.shape ? JSON.stringify(sub.shape) : '';
-            const subFilterKey = sub.filter ? JSON.stringify(sub.filter) : '';
-            const subSortKey = sub.sort ? JSON.stringify(sub.sort) : '';
             // H1: also require the same principal identity (compact hash AND exact
             // token) — a different logged-in user must not piggy-back on (and
             // inherit lastData from) another user's existing subscription, even
             // with identical path/prompt/shape/filter/sort.
-            if (sub.identity === identity && sub.identityToken === identityToken && sub.path === normalizedPath && sub.prompt === subscriptionOptions.prompt && subShapeKey === shapeKey && subFilterKey === filterKey && subSortKey === sortKey && sub.includeSubPaths === ((_a = subscriptionOptions.includeSubPaths) !== null && _a !== void 0 ? _a : false) && sub.limit === subscriptionOptions.limit && sub.cursor === subscriptionOptions.cursor) {
+            if (sub.identity === identity && sub.identityToken === identityToken && sub.path === normalizedPath && sub.prompt === subscriptionOptions.prompt && sub.specKey === specKey && sub.includeSubPaths === ((_d = subscriptionOptions.includeSubPaths) !== null && _d !== void 0 ? _d : false) && sub.limit === subscriptionOptions.limit && sub.cursor === subscriptionOptions.cursor) {
                 existingSubscription = sub;
                 break;
             }
@@ -6899,7 +7577,7 @@ async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
             shape: subscriptionOptions.shape,
             limit: subscriptionOptions.limit,
             cursor: subscriptionOptions.cursor,
-            includeSubPaths: (_b = subscriptionOptions.includeSubPaths) !== null && _b !== void 0 ? _b : false,
+            includeSubPaths: (_e = subscriptionOptions.includeSubPaths) !== null && _e !== void 0 ? _e : false,
             callbacks: [subscriptionOptions],
             lastData: undefined,
             dataRevision: 0,
@@ -6907,6 +7585,7 @@ async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
             cache: responseCacheEnabled,
             identity,
             identityToken,
+            specKey,
         };
         connection.subscriptions.set(subscriptionId, subscription);
     }
@@ -7907,6 +8586,8 @@ function defineLiveModule(mod) {
     return mod;
 }
 
+exports.BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR = BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR;
+exports.BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR = BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR;
 exports.BoundedDeclineError = BoundedDeclineError;
 exports.DECLINE_EVENT_NAME = DECLINE_EVENT_NAME;
 exports.EFFECT_INTENT_ADDRESS = EFFECT_INTENT_ADDRESS;
@@ -7917,6 +8598,8 @@ exports.ReactNativeSessionManager = ReactNativeSessionManager;
 exports.ServerSessionManager = ServerSessionManager;
 exports.WebSessionManager = WebSessionManager;
 exports.aggregate = aggregate;
+exports.assertCanonicalBoundedRuntimeWriteCalldata = assertCanonicalBoundedRuntimeWriteCalldata;
+exports.assertEvmTransactionMatchesWrite = assertEvmTransactionMatchesWrite;
 exports.buildSetDocumentsTransaction = buildSetDocumentsTransaction;
 exports.clearCache = clearCache;
 exports.closeAllSubscriptions = closeAllSubscriptions;
@@ -7930,6 +8613,7 @@ exports.dispatchDeclineEvent = dispatchDeclineEvent;
 exports.docId = docId;
 exports.functions = functions;
 exports.genAuthNonce = genAuthNonce;
+exports.genSiweMessage = genSiweMessage;
 exports.genSolanaMessage = genSolanaMessage;
 exports.get = get;
 exports.getActiveSessionManager = getActiveSessionManager;
@@ -7947,6 +8631,7 @@ exports.isEffectResult = isEffectResult;
 exports.live = live;
 exports.liveIntent = intent;
 exports.liveStatus = status;
+exports.normalizeEvmAddress = normalizeEvmAddress;
 exports.now = now;
 exports.queryAggregate = queryAggregate;
 exports.reconnectWithNewAuth = reconnectWithNewAuth;
@@ -7967,6 +8652,7 @@ exports.signSessionCreateMessage = signSessionCreateMessage;
 exports.signTransaction = signTransaction;
 exports.subscribe = subscribe;
 exports.subscribeLiveView = subscribeView;
+exports.toLowerEvmAddress = toLowerEvmAddress;
 exports.toMillis = toMillis;
 exports.toSeconds = toSeconds;
 exports.withEffects = withEffects;