@bounded-sh/core 0.0.42 → 0.0.44

package/dist/index.mjs

@@ -31,6 +31,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',
@@ -99,23 +103,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();
@@ -2801,8 +2799,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;
@@ -2811,7 +2825,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,
@@ -2826,11 +2840,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;
         }
@@ -3605,12 +3619,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.
@@ -3619,10 +3634,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);
         }
@@ -3726,6 +3761,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;
@@ -3774,7 +3936,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 {
@@ -3787,14 +3949,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;
@@ -4116,6 +4289,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)
@@ -4252,6 +4875,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;
@@ -4262,10 +4900,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;
@@ -5146,13 +5784,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();
@@ -5208,6 +5845,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 });
@@ -5217,9 +5857,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 {
@@ -5243,7 +5909,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 {
@@ -5343,6 +6009,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();
@@ -6723,7 +7397,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
@@ -6774,19 +7448,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;
             }
@@ -6879,7 +7557,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,
@@ -6887,6 +7565,7 @@ async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
             cache: responseCacheEnabled,
             identity,
             identityToken,
+            specKey,
         };
         connection.subscriptions.set(subscriptionId, subscription);
     }
@@ -7887,5 +8566,5 @@ function defineLiveModule(mod) {
     return mod;
 }
 
-export { BoundedDeclineError, DECLINE_EVENT_NAME, EFFECT_INTENT_ADDRESS, FunctionInvokeError, InsufficientBalanceError, LiveIntentError, ReactNativeSessionManager, ServerSessionManager, WebSessionManager, aggregate, buildSetDocumentsTransaction, clearCache, closeAllSubscriptions, convertRemainingAccounts, count, createSessionWithSignature, defineLiveModule, deriveDecline, deriveUserIdentityFromIdToken, dispatchDeclineEvent, docId, functions, genAuthNonce, genSolanaMessage, get, getActiveSessionManager, getCachedData, getConfig, getFiles, getIdToken, getMany, getWebhookKeysUrl, hasActiveConnection, increment, init, invoke as invokeFunction, isEffectResult, live, intent as liveIntent, status as liveStatus, now, queryAggregate, reconnectWithNewAuth, refreshSession, revokeSession, runExpression, runExpressionMany, runQuery, runQueryMany, search, serverTimestamp, set, setFile, setMany, signAndSubmitTransaction, signMessage, signSessionCreateMessage, signTransaction, subscribe, subscribeView as subscribeLiveView, toMillis, toSeconds, withEffects };
+export { BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR, BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR, BoundedDeclineError, DECLINE_EVENT_NAME, EFFECT_INTENT_ADDRESS, FunctionInvokeError, InsufficientBalanceError, LiveIntentError, ReactNativeSessionManager, ServerSessionManager, WebSessionManager, aggregate, assertCanonicalBoundedRuntimeWriteCalldata, assertEvmTransactionMatchesWrite, buildSetDocumentsTransaction, clearCache, closeAllSubscriptions, convertRemainingAccounts, count, createSessionWithSignature, defineLiveModule, deriveDecline, deriveUserIdentityFromIdToken, dispatchDeclineEvent, docId, functions, genAuthNonce, genSiweMessage, genSolanaMessage, get, getActiveSessionManager, getCachedData, getConfig, getFiles, getIdToken, getMany, getWebhookKeysUrl, hasActiveConnection, increment, init, invoke as invokeFunction, isEffectResult, live, intent as liveIntent, status as liveStatus, normalizeEvmAddress, now, queryAggregate, reconnectWithNewAuth, refreshSession, revokeSession, runExpression, runExpressionMany, runQuery, runQueryMany, search, serverTimestamp, set, setFile, setMany, signAndSubmitTransaction, signMessage, signSessionCreateMessage, signTransaction, subscribe, subscribeView as subscribeLiveView, toLowerEvmAddress, toMillis, toSeconds, withEffects };
 //# sourceMappingURL=index.mjs.map