@bounded-sh/core 0.0.41 → 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;
         }
@@ -2929,7 +2943,14 @@ async function revokeSession(refreshToken, issuer) {
         await axios.post(`${base}/session/revoke`, {
             refreshToken,
             appId: config.appId,
-        }, { headers: { 'Content-Type': 'application/json' }, timeout: 15000 });
+        }, {
+            headers: { 'Content-Type': 'application/json' },
+            timeout: 15000,
+            // Preserve the transport error for programmatic diagnostics while
+            // ensuring AxiosError.toJSON() cannot serialize the live token body
+            // into logs, telemetry, UI state, or crash reports.
+            redact: ['data'],
+        });
     }
     catch (err) {
         throw new SessionRevokeError(revokeFailureMessage(err), err);
@@ -3618,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.
@@ -3632,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);
         }
@@ -3739,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;
@@ -3787,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 {
@@ -3800,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;
@@ -4129,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)
@@ -4155,12 +4785,21 @@ class InsufficientBalanceError extends Error {
         this.deficitSol = deficitSol;
     }
 }
-// Cache for get responses
 const getCache = {};
-// Track in-flight requests to coalesce multiple identical requests
 const pendingRequests = {};
 // Default cache TTL (500ms = 0.5 seconds)
 const GET_CACHE_TTL = 500; // Adjust this value as needed (in milliseconds)
+function getReadCacheEntry(cacheKey, principalValue) {
+    var _a;
+    return (_a = getCache[cacheKey]) === null || _a === void 0 ? void 0 : _a.find(entry => entry.principalValue === principalValue);
+}
+function setReadCacheEntry(cacheKey, principalValue, data, expiresAt) {
+    var _a;
+    const bucket = (_a = getCache[cacheKey]) !== null && _a !== void 0 ? _a : [];
+    const reusableEntries = bucket.filter(entry => (entry.principalValue !== principalValue && entry.expiresAt >= Date.now()));
+    reusableEntries.push({ data, expiresAt, principalValue });
+    getCache[cacheKey] = reusableEntries;
+}
 // Last time we cleaned up the cache
 let lastCacheCleanup = Date.now();
 let uncacheableReadKeyCounter = 0;
@@ -4256,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;
@@ -4266,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;
@@ -4291,32 +4945,34 @@ async function getReadPrincipalKey(overrides) {
     // makeApiRequest applies overrides.headers AFTER its computed auth header, so
     // caller-supplied Authorization is the real request auth when present.
     if (hasAuthHeader(overrides === null || overrides === void 0 ? void 0 : overrides.headers)) {
-        const principal = principalFromAuthValue(authValueFromHeaders(overrides === null || overrides === void 0 ? void 0 : overrides.headers));
+        const authValue = authValueFromHeaders(overrides === null || overrides === void 0 ? void 0 : overrides.headers);
+        const principal = principalFromAuthValue(authValue);
         return principal
-            ? { key: `${appId}:${principal}`, cacheable: true }
-            : { key: uncacheableReadKey(appId, 'h'), cacheable: false };
+            ? { key: `${appId}:${principal}`, cacheable: true, principalValue: authValue }
+            : { key: uncacheableReadKey(appId, 'h'), cacheable: false, principalValue: null };
     }
     // Per-request auth-header override (wallet client). Key by the exact opaque
     // header it produces, not decoded claims or the unverified _walletAddress hint.
     if (overrides === null || overrides === void 0 ? void 0 : overrides._getAuthHeaders) {
         try {
             const headers = await overrides._getAuthHeaders();
-            const principal = principalFromAuthValue(authValueFromHeaders(headers));
+            const authValue = authValueFromHeaders(headers);
+            const principal = principalFromAuthValue(authValue);
             return principal
-                ? { key: `${appId}:o${principal}`, cacheable: true }
-                : { key: uncacheableReadKey(appId, 'o'), cacheable: false };
+                ? { key: `${appId}:o${principal}`, cacheable: true, principalValue: authValue }
+                : { key: uncacheableReadKey(appId, 'o'), cacheable: false, principalValue: null };
         }
         catch (_a) {
             // If we can't resolve the override identity, do not read/write cache.
-            return { key: uncacheableReadKey(appId, 'o'), cacheable: false };
+            return { key: uncacheableReadKey(appId, 'o'), cacheable: false, principalValue: null };
         }
     }
     // Ambient session principal.
     const idToken = await getIdToken(config.isServer);
     const principal = principalFromIdToken$1(idToken);
     return principal
-        ? { key: `${appId}:${principal}`, cacheable: true }
-        : { key: uncacheableReadKey(appId, 'a'), cacheable: false };
+        ? { key: `${appId}:${principal}`, cacheable: true, principalValue: idToken !== null && idToken !== void 0 ? idToken : null }
+        : { key: uncacheableReadKey(appId, 'a'), cacheable: false, principalValue: null };
 }
 /**
  * Validates that a field name is a safe identifier (alphanumeric, underscores, dots for nested paths).
@@ -4597,6 +5253,7 @@ async function search(path, query, opts = {}) {
     return response.data;
 }
 async function get(path, opts = {}) {
+    var _a, _b;
     try {
         let normalizedPath = path.startsWith("/") ? path.slice(1) : path;
         // Remove last '*' if it exists in the path
@@ -4607,7 +5264,8 @@ async function get(path, opts = {}) {
             throw new Error("Invalid path provided.");
         }
         // Create cache key combining path, prompt, filter, sort, includeSubPaths,
-        // shape, limit, cursor — and (H1) the caller's appId + principal fingerprint,
+        // shape, limit, cursor — and (H1) the caller's appId + compact principal
+        // bucket. Exact opaque credential equality is checked inside that bucket,
         // so a private read cached for one user is never served to another in a
         // shared process / SSR worker / browser login-switch. The cache is opt-in
         // and disabled for no-auth reads, which get an uncacheable unique key.
@@ -4622,20 +5280,25 @@ async function get(path, opts = {}) {
         const cacheEnabled = opts.cache === true && !opts.bypassCache && principalKey.cacheable;
         const now = Date.now();
         // Check for valid cache entry when the caller explicitly opted in.
-        if (cacheEnabled && getCache[cacheKey] && now < getCache[cacheKey].expiresAt) {
-            return getCache[cacheKey].data;
+        const cachedEntry = getReadCacheEntry(cacheKey, principalKey.principalValue);
+        if (cacheEnabled &&
+            cachedEntry &&
+            now < cachedEntry.expiresAt) {
+            return cachedEntry.data;
         }
         // If we're bypassing cache, we should still coalesce identical requests
         // but need a different key to avoid interfering with regular requests
         const requestKey = opts.bypassCache ? `bypass:${cacheKey}` : cacheKey;
-        // Check if there's already an in-flight request for this key
-        // Fix for TS error - use hasOwnProperty to explicitly check if key exists
-        if (Object.prototype.hasOwnProperty.call(pendingRequests, requestKey)) {
-            // Return the existing promise to coalesce requests
-            return pendingRequests[requestKey];
+        // The compact principal hash is only an index bucket. Coalesce only when
+        // the exact opaque credential also matches, so collisions stay isolated.
+        const existingPending = (_a = pendingRequests[requestKey]) === null || _a === void 0 ? void 0 : _a.find(entry => entry.principalValue === principalKey.principalValue);
+        if (existingPending) {
+            return existingPending.promise;
         }
         // Create a new request promise and store it
-        const requestPromise = (async () => {
+        let requestPromise;
+        requestPromise = (async () => {
+            var _a;
             try {
                 const pathIsDocument = normalizedPath.split("/").length % 2 === 0;
                 // Cache miss or bypass - proceed with HTTP API request
@@ -4666,10 +5329,7 @@ async function get(path, opts = {}) {
                 const responseData = normalizeReadResult(response.data, pathIsDocument);
                 // Cache the response only when explicitly requested and principal-bound.
                 if (cacheEnabled) {
-                    getCache[cacheKey] = {
-                        data: responseData,
-                        expiresAt: now + GET_CACHE_TTL
-                    };
+                    setReadCacheEntry(cacheKey, principalKey.principalValue, responseData, now + GET_CACHE_TTL);
                     // Periodically clean up expired cache entries (every 5 seconds)
                     if (now - lastCacheCleanup > 5000) {
                         cleanupExpiredCache();
@@ -4680,12 +5340,21 @@ async function get(path, opts = {}) {
                 return responseData;
             }
             finally {
-                // Remove this request from pendingRequests regardless of success/failure
-                delete pendingRequests[requestKey];
+                // Remove only this exact request. A colliding principal can legitimately
+                // have another request in the same compact-hash bucket.
+                const bucket = pendingRequests[requestKey];
+                const index = (_a = bucket === null || bucket === void 0 ? void 0 : bucket.findIndex(entry => entry.promise === requestPromise)) !== null && _a !== void 0 ? _a : -1;
+                if (index >= 0)
+                    bucket.splice(index, 1);
+                if ((bucket === null || bucket === void 0 ? void 0 : bucket.length) === 0)
+                    delete pendingRequests[requestKey];
             }
         })();
-        // Store the promise so other calls can join it
-        pendingRequests[requestKey] = requestPromise;
+        // Store the promise so only callers with the exact same credential join it.
+        ((_b = pendingRequests[requestKey]) !== null && _b !== void 0 ? _b : (pendingRequests[requestKey] = [])).push({
+            principalValue: principalKey.principalValue,
+            promise: requestPromise,
+        });
         // Return the promise
         return requestPromise;
     }
@@ -4697,9 +5366,12 @@ async function get(path, opts = {}) {
 function cleanupExpiredCache() {
     const now = Date.now();
     Object.keys(getCache).forEach(key => {
-        if (getCache[key] && getCache[key].expiresAt < now) {
+        var _a, _b;
+        const activeEntries = (_b = (_a = getCache[key]) === null || _a === void 0 ? void 0 : _a.filter(entry => entry.expiresAt >= now)) !== null && _b !== void 0 ? _b : [];
+        if (activeEntries.length > 0)
+            getCache[key] = activeEntries;
+        else
             delete getCache[key];
-        }
     });
     lastCacheCleanup = now;
 }
@@ -4961,8 +5633,11 @@ async function getMany(paths, opts = {}) {
     for (let i = 0; i < normalizedPaths.length; i++) {
         const normalizedPath = normalizedPaths[i];
         const cacheKey = `${principalKey.key}|${normalizedPath}:`;
-        if (cacheEnabled && getCache[cacheKey] && now < getCache[cacheKey].expiresAt) {
-            results[i] = { path: normalizedPath, data: getCache[cacheKey].data };
+        const cachedEntry = getReadCacheEntry(cacheKey, principalKey.principalValue);
+        if (cacheEnabled &&
+            cachedEntry &&
+            now < cachedEntry.expiresAt) {
+            results[i] = { path: normalizedPath, data: cachedEntry.data };
         }
         else {
             uncachedIndices.push(i);
@@ -4999,10 +5674,7 @@ async function getMany(paths, opts = {}) {
                     results[originalIndex] = normalizedResult;
                     if (!normalizedResult.error && cacheEnabled) {
                         const cacheKey = `${principalKey.key}|${normalizedPath}:`;
-                        getCache[cacheKey] = {
-                            data: normalizedResult.data,
-                            expiresAt: now + GET_CACHE_TTL
-                        };
+                        setReadCacheEntry(cacheKey, principalKey.principalValue, normalizedResult.data, now + GET_CACHE_TTL);
                     }
                 }
                 else {
@@ -5132,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();
@@ -5194,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 });
@@ -5203,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 {
@@ -5229,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 {
@@ -5329,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();
@@ -5569,10 +6277,37 @@ var operations = /*#__PURE__*/Object.freeze({
 // ============ Global State ============
 // One connection per routing target (appId, or appId#room#<collection>/<roomId>)
 const connections = new Map();
+// Coalesce concurrent first-use/auth-preflight calls for the same routing target.
+// React commonly mounts several subscriptions in one render; without this map,
+// every call can pass the empty `connections` check, await auth, and create an
+// orphan ReconnectingWebSocket before the first call publishes its connection.
+// Keyed by the identity-bucket lease key (see connectionLeaseKey) so two distinct
+// wallet tokens never share one in-flight socket even under a compact-hash collision.
+const connectionFlights = new Map();
+// A subscriber holds a routing-target lease from connection acquisition until
+// its callback/subscription is registered. The last old-route unsubscribe must
+// not close a connection already captured by a new route awaiting auth. Keyed by
+// the same identity-bucket lease key as connectionFlights.
+const connectionAcquisitions = new Map();
+// Compact identity hashes remain useful bounded-size indexes, but collisions
+// share a bucket instead of sharing authority. Each exact bearer keeps its own
+// cache entry so collision isolation does not evict another principal's cache.
 const responseCache = new Map();
 const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
 const TOKEN_REFRESH_BUFFER = 10 * 60 * 1000; // Refresh token 10 minutes before expiry
 const TOKEN_CHECK_INTERVAL = 5 * 60 * 1000; // Check token freshness every 5 minutes
+function getResponseCacheEntry(cacheKey, identityToken) {
+    var _a;
+    return (_a = responseCache.get(cacheKey)) === null || _a === void 0 ? void 0 : _a.find(entry => entry.identityToken === identityToken);
+}
+function setResponseCacheEntry(cacheKey, identityToken, data) {
+    var _a;
+    const now = Date.now();
+    const bucket = (_a = responseCache.get(cacheKey)) !== null && _a !== void 0 ? _a : [];
+    const reusableEntries = bucket.filter(entry => (entry.identityToken !== identityToken && now - entry.timestamp < CACHE_TTL));
+    reusableEntries.push({ data, timestamp: now, identityToken });
+    responseCache.set(cacheKey, reusableEntries);
+}
 // ============ WebSocket Config ============
 const BASE_MIN_RECONNECT_DELAY_MS = 1000;
 const MIN_RECONNECT_DELAY_JITTER_MS = 1000;
@@ -5580,6 +6315,10 @@ const MAX_RECONNECT_DELAY_MS = 300000;
 const RECONNECT_DELAY_GROW_FACTOR = 1.8;
 const MIN_BROWSER_RECONNECT_INTERVAL_MS = 5000;
 const WS_AUTH_EXPIRED_CODE = 'auth_expired';
+// React runs old-route effect cleanup before new-route effects. Keep an
+// otherwise-idle socket for one short handoff window so the new route can
+// cancel teardown and reuse it; genuinely idle sockets still close promptly.
+const IDLE_CONNECTION_CLOSE_GRACE_MS = 1000;
 const WS_CONFIG = {
     // Keep retrying indefinitely so long outages recover without page refresh.
     maxRetries: Infinity,
@@ -5610,12 +6349,12 @@ function hashForKey(value) {
 }
 /**
  * SECURITY (H1): Response-cache keys must be scoped to the caller's identity, not
- * just the path/filter/shape. The `identity` prefix (`<appId>:<principal>`) keeps
- * a private subscription snapshot cached for one user from being delivered to a
- * different user who subscribes with the same options (shared process / SSR worker
- * / browser login-switch; this cache has a 5-minute TTL). Callers must opt in
- * before entries are read or written; no-auth subscriptions never populate an
- * implicit anonymous cache bucket.
+ * just the path/filter/shape. The compact `identity` prefix selects a bucket;
+ * exact opaque bearer equality is required inside it before reuse. Together they
+ * keep a private snapshot from being delivered to a different user with the same
+ * options (shared process / SSR worker / browser login-switch; this cache has a
+ * 5-minute TTL). Callers must opt in before entries are read or written; no-auth
+ * subscriptions never populate an implicit anonymous cache bucket.
  */
 function getCacheKey(path, prompt, shape, limit, cursor, filter, identity) {
     const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
@@ -5653,16 +6392,16 @@ function livePrincipalFromIdToken(idToken) {
 }
 function authSnapshotFromToken(idToken) {
     return {
-        tokenFingerprint: principalFromIdToken(idToken),
+        tokenValue: idToken !== null && idToken !== void 0 ? idToken : null,
         principal: livePrincipalFromIdToken(idToken),
     };
 }
 function connectionMatchesAuthToken(connection, idToken) {
     const current = authSnapshotFromToken(idToken);
-    if (!current.tokenFingerprint) {
-        return connection.authTokenFingerprint === null && connection.authPrincipal === null;
+    if (!current.tokenValue) {
+        return connection.authTokenValue === null && connection.authPrincipal === null;
     }
-    if (connection.authTokenFingerprint && connection.authTokenFingerprint === current.tokenFingerprint) {
+    if (connection.authTokenValue && connection.authTokenValue === current.tokenValue) {
         return true;
     }
     return !!connection.authPrincipal && !!current.principal && connection.authPrincipal === current.principal;
@@ -5671,7 +6410,7 @@ async function canSendAuthenticatedLiveIntent(connection, isServer) {
     const currentToken = await getIdToken(isServer);
     if (!currentToken)
         return false;
-    if (!connection.authTokenFingerprint && !connection.authPrincipal)
+    if (!connection.authTokenValue && !connection.authPrincipal)
         return false;
     return connectionMatchesAuthToken(connection, currentToken);
 }
@@ -5684,19 +6423,19 @@ async function getSubscriptionIdentity(effectiveAppId, isServer, overrides) {
             const bearer = bearerFromAuthHeaders(await overrides._getAuthHeaders());
             const principal = principalFromIdToken(bearer);
             return principal
-                ? { key: `${effectiveAppId}:o${principal}`, cacheable: true }
-                : { key: `${effectiveAppId}:oanon`, cacheable: false };
+                ? { key: `${effectiveAppId}:o${principal}`, cacheable: true, token: bearer }
+                : { key: `${effectiveAppId}:oanon`, cacheable: false, token: null };
         }
         catch (_a) {
             // Couldn't resolve the override identity — do not use response cache.
-            return { key: `${effectiveAppId}:o-uncacheable-${safeBtoa(String(connectionEpoch++))}`, cacheable: false };
+            return { key: `${effectiveAppId}:o-uncacheable-${safeBtoa(String(connectionEpoch++))}`, cacheable: false, token: null };
         }
     }
     const idToken = await getIdToken(isServer);
     const principal = principalFromIdToken(idToken);
     return principal
-        ? { key: `${effectiveAppId}:${principal}`, cacheable: true }
-        : { key: `${effectiveAppId}:anon`, cacheable: false };
+        ? { key: `${effectiveAppId}:${principal}`, cacheable: true, token: idToken !== null && idToken !== void 0 ? idToken : null }
+        : { key: `${effectiveAppId}:anon`, cacheable: false, token: null };
 }
 /** Extract the bare bearer token from a `{ Authorization: 'Bearer <jwt>' }` map. */
 function bearerFromAuthHeaders(headers) {
@@ -5752,7 +6491,7 @@ function failConnectionAuth(connection, error) {
     connection.authFailure = error;
     connection.pendingAuthToken = null;
     connection.pendingAuthSnapshot = null;
-    connection.authTokenFingerprint = null;
+    connection.authTokenValue = null;
     connection.authPrincipal = null;
     connection.isConnecting = false;
     connection.isConnected = false;
@@ -5763,6 +6502,7 @@ function failConnectionAuth(connection, error) {
     connection.pendingSubscriptions.clear();
     for (const subscription of connection.subscriptions.values()) {
         notifyErrorCallbacks(subscription, error);
+        rejectSubscriptionRefresh(subscription, error);
     }
 }
 function scheduleTokenRefresh(connection, isServer) {
@@ -5955,7 +6695,136 @@ function replaySubscriptions(connection) {
         sendSubscribe(connection, sub);
     }
 }
-async function getOrCreateConnection(appId, isServer, routePath, authTokenProvider, principalKey) {
+/**
+ * Derive the stable identity-bucket lease key used to coalesce (singleflight)
+ * and refcount (acquisition / idle-close) connection use. Ambient app/room
+ * connections key by their routing target; wallet-scoped connections pin the
+ * exact bearer so two distinct tokens never share a flight or a lease, even
+ * when their compact `#id#<principalKey>` hashes collide.
+ */
+function connectionLeaseKey(appId, routePath, principalKey, principalToken) {
+    const roomKey = roomKeyFromRoutePath(routePath);
+    const base = roomKey ? `${appId}#room#${roomKey}` : appId;
+    if (!principalKey)
+        return base;
+    const bucket = `${base}#id#${principalKey}`;
+    return principalToken ? `${bucket}#tok#${principalToken}` : bucket;
+}
+function cancelIdleConnectionClose(connection) {
+    if (!connection.idleCloseTimer)
+        return;
+    clearTimeout(connection.idleCloseTimer);
+    connection.idleCloseTimer = null;
+}
+function closeConnectionNow(connection) {
+    if (connections.get(connection.key) !== connection)
+        return;
+    if (!connection.ws)
+        return;
+    cancelIdleConnectionClose(connection);
+    if (connection.tokenRefreshTimer) {
+        clearInterval(connection.tokenRefreshTimer);
+        connection.tokenRefreshTimer = null;
+    }
+    const ws = connection.ws;
+    connection.ws = null;
+    connection.isConnecting = false;
+    connection.isConnected = false;
+    connection.isAuthenticating = false;
+    const closeError = new Error('WebSocket connection closed');
+    for (const subscription of connection.subscriptions.values()) {
+        rejectSubscriptionRefresh(subscription, closeError);
+    }
+    connections.delete(connection.key);
+    try {
+        ws.close();
+    }
+    catch ( /* already closing */_a) { /* already closing */ }
+}
+function scheduleConnectionCloseIfIdle(connection) {
+    var _a;
+    if (connections.get(connection.key) !== connection)
+        return;
+    if (connection.subscriptions.size > 0)
+        return;
+    if (((_a = connectionAcquisitions.get(connection.acquisitionKey)) !== null && _a !== void 0 ? _a : 0) > 0)
+        return;
+    if (!connection.ws || connection.idleCloseTimer)
+        return;
+    connection.idleCloseTimer = setTimeout(() => {
+        var _a;
+        connection.idleCloseTimer = null;
+        if (connection.subscriptions.size > 0)
+            return;
+        if (((_a = connectionAcquisitions.get(connection.acquisitionKey)) !== null && _a !== void 0 ? _a : 0) > 0)
+            return;
+        closeConnectionNow(connection);
+    }, IDLE_CONNECTION_CLOSE_GRACE_MS);
+}
+/**
+ * Acquire a connection under a routing-target lease. The lease is refcounted on
+ * the identity-bucket key and held across the caller's auth preflight so a
+ * concurrent old-route teardown cannot close a socket a new route is about to
+ * reuse. The lease is released once the caller has registered its
+ * subscription/callback.
+ */
+async function acquireConnection(appId, isServer, routePath, authTokenProvider, principalKey, principalToken) {
+    var _a;
+    const leaseKey = connectionLeaseKey(appId, routePath, principalKey, principalToken);
+    connectionAcquisitions.set(leaseKey, ((_a = connectionAcquisitions.get(leaseKey)) !== null && _a !== void 0 ? _a : 0) + 1);
+    let released = false;
+    let releaseTimer = null;
+    const release = (connection) => {
+        var _a;
+        if (released)
+            return;
+        released = true;
+        if (releaseTimer) {
+            clearTimeout(releaseTimer);
+            releaseTimer = null;
+        }
+        const remaining = ((_a = connectionAcquisitions.get(leaseKey)) !== null && _a !== void 0 ? _a : 1) - 1;
+        if (remaining > 0)
+            connectionAcquisitions.set(leaseKey, remaining);
+        else
+            connectionAcquisitions.delete(leaseKey);
+        if (connection)
+            scheduleConnectionCloseIfIdle(connection);
+    };
+    try {
+        const connection = await getOrCreateConnection(appId, isServer, routePath, authTokenProvider, principalKey, principalToken);
+        const releaseConnection = () => release(connection);
+        // Registration is synchronous after the caller's await. This fail-safe
+        // releases on the next task even if an option getter/callback throws
+        // before subscribeV2 reaches its explicit release path.
+        releaseTimer = setTimeout(releaseConnection, 0);
+        return { connection, release: releaseConnection };
+    }
+    catch (error) {
+        release();
+        throw error;
+    }
+}
+async function getOrCreateConnection(appId, isServer, routePath, authTokenProvider, principalKey, principalToken) {
+    // Singleflight: concurrent first-use of the same routing target shares one
+    // in-flight connection rather than each creating an orphan socket. Keyed by
+    // the identity-bucket lease key so distinct wallet tokens never coalesce.
+    const leaseKey = connectionLeaseKey(appId, routePath, principalKey, principalToken);
+    const activeFlight = connectionFlights.get(leaseKey);
+    if (activeFlight)
+        return activeFlight;
+    const flight = getOrCreateConnectionOnce(appId, isServer, routePath, authTokenProvider, principalKey, principalToken, leaseKey);
+    connectionFlights.set(leaseKey, flight);
+    try {
+        return await flight;
+    }
+    finally {
+        if (connectionFlights.get(leaseKey) === flight) {
+            connectionFlights.delete(leaseKey);
+        }
+    }
+}
+async function getOrCreateConnectionOnce(appId, isServer, routePath, authTokenProvider, principalKey, principalToken, leaseKey) {
     attachBrowserReconnectHooksOnce();
     // A per-room subscription gets its OWN connection routed to the room DO; all
     // other subscriptions share the app-level connection (project DO). The worker
@@ -5966,9 +6835,38 @@ async function getOrCreateConnection(appId, isServer, routePath, authTokenProvid
     // keyed by the wallet identity, so its WS authenticates as that wallet and
     // never shares a connection (or token) with any top-level server caller.
     const base = roomKey ? `${appId}#room#${roomKey}` : appId;
-    const connKey = principalKey ? `${base}#id#${principalKey}` : base;
-    let connection = connections.get(connKey);
+    const identityBucketKey = principalKey
+        ? `${base}#id#${principalKey}`
+        : base;
+    let connKey = identityBucketKey;
+    let connection;
+    if (principalKey && principalToken) {
+        // The 31-bit hash selects a small bucket only. Exact token equality is
+        // authoritative, and a rare collision gets an independent map slot.
+        for (const [candidateKey, candidate] of connections) {
+            if ((candidateKey === identityBucketKey || candidateKey.startsWith(`${identityBucketKey}#collision#`)) &&
+                candidate.connectionIdentityToken === principalToken) {
+                connKey = candidateKey;
+                connection = candidate;
+                break;
+            }
+        }
+        if (!connection && connections.has(connKey)) {
+            let collisionIndex = 1;
+            while (connections.has(`${identityBucketKey}#collision#${collisionIndex}`))
+                collisionIndex += 1;
+            connKey = `${identityBucketKey}#collision#${collisionIndex}`;
+        }
+    }
+    else {
+        connection = connections.get(connKey);
+    }
     if (connection && connection.ws) {
+        // We may reuse this connection; cancel any pending idle-close so it is
+        // not torn down during the auth preflight below. The held acquisition
+        // lease also guards this window, but cancelling here avoids a needless
+        // grace-timer round-trip on the common reuse path.
+        cancelIdleConnectionClose(connection);
         if (connection.authFailure) {
             throw connection.authFailure;
         }
@@ -5984,19 +6882,7 @@ async function getOrCreateConnection(appId, isServer, routePath, authTokenProvid
         if (connection.isConnected &&
             !connection.isAuthenticating &&
             !connectionMatchesAuthToken(connection, currentAuthToken)) {
-            if (connection.tokenRefreshTimer) {
-                clearInterval(connection.tokenRefreshTimer);
-                connection.tokenRefreshTimer = null;
-            }
-            try {
-                connection.ws.close();
-            }
-            catch (_a) {
-                // Already closing.
-            }
-            connection.ws = null;
-            connection.isConnected = false;
-            connections.delete(connection.key);
+            closeConnectionNow(connection);
         }
         else {
             connection.authFailure = null;
@@ -6017,13 +6903,16 @@ async function getOrCreateConnection(appId, isServer, routePath, authTokenProvid
         isAuthenticating: false,
         appId,
         key: connKey,
+        acquisitionKey: leaseKey,
         routePath: roomKey ? routePath : undefined,
         authTokenProvider,
+        connectionIdentityToken: principalToken !== null && principalToken !== void 0 ? principalToken : null,
         pendingAuthToken: null,
         pendingAuthSnapshot: null,
-        authTokenFingerprint: null,
+        authTokenValue: null,
         authPrincipal: null,
         tokenRefreshTimer: null,
+        idleCloseTimer: null,
         consecutiveAuthFailures: 0,
         authFailure: null,
     };
@@ -6100,7 +6989,7 @@ async function getOrCreateConnection(appId, isServer, routePath, authTokenProvid
         }
         else {
             connection.isAuthenticating = false;
-            connection.authTokenFingerprint = null;
+            connection.authTokenValue = null;
             connection.authPrincipal = null;
             replaySubscriptions(connection);
         }
@@ -6118,10 +7007,14 @@ async function getOrCreateConnection(appId, isServer, routePath, authTokenProvid
     // Handle errors
     ws.addEventListener('error', (event) => {
         console.error('[WS v2] WebSocket error:', event);
+        const wsError = new Error('WebSocket error');
         for (const [, pending] of connection.pendingSubscriptions) {
-            pending.reject(new Error('WebSocket error'));
+            pending.reject(wsError);
         }
         connection.pendingSubscriptions.clear();
+        for (const subscription of connection.subscriptions.values()) {
+            rejectSubscriptionRefresh(subscription, wsError);
+        }
     });
     // Handle close
     ws.addEventListener('close', () => {
@@ -6145,7 +7038,7 @@ function handleServerMessage(connection, message) {
     switch (message.type) {
         case 'authenticated': {
             connection.isAuthenticating = false;
-            connection.authTokenFingerprint = (_b = (_a = connection.pendingAuthSnapshot) === null || _a === void 0 ? void 0 : _a.tokenFingerprint) !== null && _b !== void 0 ? _b : null;
+            connection.authTokenValue = (_b = (_a = connection.pendingAuthSnapshot) === null || _a === void 0 ? void 0 : _a.tokenValue) !== null && _b !== void 0 ? _b : null;
             connection.authPrincipal = (_d = (_c = connection.pendingAuthSnapshot) === null || _c === void 0 ? void 0 : _c.principal) !== null && _d !== void 0 ? _d : null;
             replaySubscriptions(connection);
             break;
@@ -6153,15 +7046,49 @@ function handleServerMessage(connection, message) {
         case 'subscribed': {
             const subscription = connection.subscriptions.get(message.subscriptionId);
             if (subscription) {
+                const refresh = subscription.refresh;
                 // A data update can race ahead of subscribed during reconnect.
                 // If we already received data for this subscription, treat subscribed
                 // as an ack only and avoid regressing to an older snapshot.
-                if (subscription.lastData === undefined) {
+                if (refresh) {
+                    const hadBaseline = subscription.lastData !== undefined;
+                    if (subscription.dataRevision === refresh.dataRevisionAtStart) {
+                        if (subscription.cache) {
+                            const cacheKey = getCacheKey(subscription.path, subscription.prompt, subscription.shape, subscription.limit, subscription.cursor, subscription.filter, subscription.identity);
+                            setResponseCacheEntry(cacheKey, subscription.identityToken, message.data);
+                        }
+                        subscription.lastData = message.data;
+                        subscription.dataRevision += 1;
+                        if (hadBaseline) {
+                            const callbacks = Array.from(refresh.callbacks)
+                                .filter((callback) => subscription.callbacks.includes(callback));
+                            notifyCallbackOptions(callbacks, message.data);
+                        }
+                        else {
+                            // The refresh joined an original registration or a
+                            // reconnect replay before its first baseline arrived.
+                            // Every active callback needs that initial snapshot.
+                            notifyCallbacks(subscription, message.data);
+                        }
+                    }
+                    else if (refresh.callbacks.size > 0 && subscription.lastData !== undefined) {
+                        // A newer authorized data frame arrived after this refresh
+                        // began. Do not regress lastData to the older subscribed
+                        // snapshot; use that newer frame for callbacks that joined
+                        // after it was broadcast.
+                        const callbacks = Array.from(refresh.callbacks)
+                            .filter((callback) => subscription.callbacks.includes(callback));
+                        notifyCallbackOptions(callbacks, subscription.lastData);
+                    }
+                    resolveSubscriptionRefresh(subscription);
+                }
+                else if (subscription.lastData === undefined) {
                     if (subscription.cache) {
                         const cacheKey = getCacheKey(subscription.path, subscription.prompt, subscription.shape, subscription.limit, subscription.cursor, subscription.filter, subscription.identity);
-                        responseCache.set(cacheKey, { data: message.data, timestamp: Date.now() });
+                        setResponseCacheEntry(cacheKey, subscription.identityToken, message.data);
                     }
                     subscription.lastData = message.data;
+                    subscription.dataRevision += 1;
                     notifyCallbacks(subscription, message.data);
                 }
             }
@@ -6188,12 +7115,20 @@ function handleServerMessage(connection, message) {
                 // Update cache
                 if (subscription.cache) {
                     const cacheKey = getCacheKey(subscription.path, subscription.prompt, subscription.shape, subscription.limit, subscription.cursor, subscription.filter, subscription.identity);
-                    responseCache.set(cacheKey, { data: message.data, timestamp: Date.now() });
+                    setResponseCacheEntry(cacheKey, subscription.identityToken, message.data);
                 }
                 // Store last data
                 subscription.lastData = message.data;
+                subscription.dataRevision += 1;
                 // Notify callbacks
                 notifyCallbacks(subscription, message.data);
+                // A data frame is itself a full, freshly authorized snapshot.
+                // It satisfies every joined callback even if the duplicate
+                // subscribed ACK was lost; resolving here prevents a false
+                // refresh timeout ten seconds after the UI already rendered.
+                if (subscription.refresh) {
+                    resolveSubscriptionRefresh(subscription);
+                }
             }
             break;
         }
@@ -6280,6 +7215,7 @@ function handleServerMessage(connection, message) {
                 const subscription = connection.subscriptions.get(message.subscriptionId);
                 if (subscription) {
                     notifyErrorCallbacks(subscription, wsError);
+                    rejectSubscriptionRefresh(subscription, wsError);
                 }
             }
             break;
@@ -6316,13 +7252,10 @@ function addIdsToSubscriptionData(data) {
         return data.map(withSubscriptionId);
     return withSubscriptionId(data);
 }
-function notifyCallbacks(subscription, data) {
+function notifyCallbackOptions(callbacks, data) {
     var _a;
     // Attach the bare `id` (leaf doc key) to every delivered row (Bug 1).
     const decorated = addIdsToSubscriptionData(data);
-    // Snapshot the callbacks array so that unsubscriptions during
-    // notification don't cause callbacks to be skipped.
-    const callbacks = subscription.callbacks.slice();
     for (const callback of callbacks) {
         try {
             (_a = callback.onData) === null || _a === void 0 ? void 0 : _a.call(callback, decorated);
@@ -6332,23 +7265,33 @@ function notifyCallbacks(subscription, data) {
         }
     }
 }
+function notifyCallbacks(subscription, data) {
+    // Snapshot the callbacks array so that unsubscriptions during
+    // notification don't cause callbacks to be skipped.
+    notifyCallbackOptions(subscription.callbacks.slice(), data);
+}
+function notifyErrorCallback(callback, error) {
+    let delivered = false;
+    try {
+        const onError = callback.onError;
+        if (!onError)
+            return false;
+        onError(error);
+        delivered = true;
+    }
+    catch (callbackError) {
+        console.error('[WS v2] Error in subscription error callback:', callbackError);
+    }
+    return delivered;
+}
 function notifyErrorCallbacks(subscription, error) {
     let delivered = false;
     const callbacks = subscription.callbacks.slice();
     for (const callback of callbacks) {
-        if (!callback.onError)
-            continue;
-        delivered = true;
-        try {
-            callback.onError(error);
-        }
-        catch (callbackError) {
-            console.error('[WS v2] Error in subscription error callback:', callbackError);
-        }
+        delivered = notifyErrorCallback(callback, error) || delivered;
     }
-    if (delivered) {
+    if (delivered)
         error.__boundedDeliveredToOnError = true;
-    }
     return delivered;
 }
 // WebSocket readyState constants
@@ -6379,6 +7322,71 @@ function sendSubscribe(connection, subscription) {
         console.error('[WS v2] Error sending subscribe message:', error);
     }
 }
+function resolveSubscriptionRefresh(subscription) {
+    const refresh = subscription.refresh;
+    if (!refresh)
+        return;
+    subscription.refresh = null;
+    if (refresh.timer)
+        clearTimeout(refresh.timer);
+    refresh.callbacks.clear();
+    refresh.resolve();
+}
+function rejectSubscriptionRefresh(subscription, error) {
+    const refresh = subscription.refresh;
+    if (!refresh)
+        return;
+    subscription.refresh = null;
+    if (refresh.timer)
+        clearTimeout(refresh.timer);
+    refresh.callbacks.clear();
+    refresh.reject(error);
+}
+/**
+ * A callback joining an already-registered non-cache subscription cannot be
+ * seeded from `lastData`: that snapshot may predate the callback's auth
+ * preflight. Re-send the same subscription id so the server re-runs read auth
+ * and returns a fresh baseline, without allocating another websocket or
+ * replacing the logical client subscription.
+ */
+function requestFreshSubscriptionSnapshot(connection, subscription, callback) {
+    let refresh = subscription.refresh;
+    if (!refresh) {
+        let resolve;
+        let reject;
+        const promise = new Promise((resolvePromise, rejectPromise) => {
+            resolve = resolvePromise;
+            reject = rejectPromise;
+        });
+        refresh = {
+            promise,
+            resolve,
+            reject,
+            timer: null,
+            callbacks: new Set(),
+            dataRevisionAtStart: subscription.dataRevision,
+        };
+        subscription.refresh = refresh;
+        refresh.timer = setTimeout(() => {
+            if (subscription.refresh !== refresh)
+                return;
+            rejectSubscriptionRefresh(subscription, new Error('Subscription timeout'));
+        }, 10000);
+    }
+    // Register before sendSubscribe: test/browser transports may synchronously
+    // dispatch the subscribed response from send().
+    refresh.callbacks.add(callback);
+    // Every newly joined callback gets an idempotent same-id resend when the
+    // authenticated socket is ready. Do not suppress this because an initial
+    // confirmation or an earlier refresh is pending: that pending frame may
+    // have been lost or displaced, and sharing it is exactly how an entire
+    // route remount can inherit one doomed timeout. When connecting or
+    // authenticating, replaySubscriptions will send after auth completes.
+    if (connection.isConnected && !connection.isAuthenticating) {
+        sendSubscribe(connection, subscription);
+    }
+    return refresh.promise;
+}
 function sendUnsubscribe(connection, subscriptionId) {
     if (!connection.ws || connection.ws.readyState !== WS_READY_STATE_OPEN) {
         return;
@@ -6409,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
@@ -6427,16 +7435,27 @@ async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
         : undefined;
     const identityInfo = await getSubscriptionIdentity(effectiveAppId, config.isServer, overrides);
     const identity = identityInfo.key;
+    const identityToken = identityInfo.token;
     const responseCacheEnabled = subscriptionOptions.cache === true && identityInfo.cacheable;
+    // Preserve the existing compact connection-key shape, but use the exact
+    // token as a secondary in-memory equality check within that hash bucket.
     const principalKey = authTokenProvider ? identity : undefined;
+    const principalToken = authTokenProvider
+        ? (identityToken !== null && identityToken !== void 0 ? identityToken : identity)
+        : undefined;
     const cacheKey = responseCacheEnabled
         ? getCacheKey(normalizedPath, subscriptionOptions.prompt, subscriptionOptions.shape, subscriptionOptions.limit, subscriptionOptions.cursor, subscriptionOptions.filter, identity)
         : null;
-    // Get or create connection for this routing target (room-scoped when a
-    // room route is supplied by the live helper, else the app-level connection).
+    // Acquire a connection for this routing target (room-scoped when a room route
+    // is supplied by the live helper, else the app-level connection). The lease is
+    // held across auth preflight and released once this call registers below, so a
+    // concurrent old-route teardown cannot close a socket we are about to reuse.
     let connection;
+    let releaseConnection;
     try {
-        connection = await getOrCreateConnection(effectiveAppId, config.isServer, roomRoutePath, authTokenProvider, principalKey);
+        const acquisition = await acquireConnection(effectiveAppId, config.isServer, roomRoutePath, authTokenProvider, principalKey, principalToken);
+        connection = acquisition.connection;
+        releaseConnection = acquisition.release;
     }
     catch (error) {
         const err = error instanceof Error ? error : new Error(String(error));
@@ -6446,73 +7465,135 @@ async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
         }
         throw err;
     }
-    // Deliver cached data immediately if available, but only after connection
-    // auth preflight has succeeded. An expired authenticated session must receive
-    // an auth error, not a stale private snapshot followed by a failed connect.
-    const cachedEntry = cacheKey ? responseCache.get(cacheKey) : undefined;
-    if (cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL && subscriptionOptions.onData) {
-        setTimeout(() => {
-            var _a;
-            (_a = subscriptionOptions.onData) === null || _a === void 0 ? void 0 : _a.call(subscriptionOptions, addIdsToSubscriptionData(cachedEntry.data));
-        }, 0);
-    }
+    const cachedEntry = cacheKey ? getResponseCacheEntry(cacheKey, identityToken) : undefined;
     // Check if we already have a subscription for this path+prompt+shape+limit+cursor+filter+sort
-    const shapeKey = subscriptionOptions.shape ? JSON.stringify(subscriptionOptions.shape) : '';
-    const filterKey = subscriptionOptions.filter ? JSON.stringify(subscriptionOptions.filter) : '';
-    const sortKey = subscriptionOptions.sort ? JSON.stringify(subscriptionOptions.sort) : '';
     let existingSubscription;
-    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 — 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.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) {
-            existingSubscription = sub;
-            break;
+    let specKey = '';
+    try {
+        // 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()) {
+            // 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 && 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;
+            }
         }
     }
+    catch (error) {
+        releaseConnection();
+        throw error;
+    }
     if (existingSubscription) {
+        let replayData = undefined;
+        let replayOnData;
+        if (responseCacheEnabled) {
+            // Read callback getters before mutating the shared subscription. If
+            // a caller supplied a throwing getter, the acquisition fail-safe can
+            // release cleanly without leaving a ghost callback behind.
+            replayOnData = subscriptionOptions.onData;
+            replayData = existingSubscription.lastData !== undefined
+                ? existingSubscription.lastData
+                : cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL
+                    ? cachedEntry.data
+                    : undefined;
+        }
         if (responseCacheEnabled) {
             existingSubscription.cache = true;
         }
         // Add callback to existing subscription
         existingSubscription.callbacks.push(subscriptionOptions);
-        // Deliver last known data immediately only for explicit, principal-bound
-        // cache opt-in. Otherwise joining an existing subscription can replay a
-        // stale private snapshot without a fresh server auth result.
-        if (responseCacheEnabled &&
-            existingSubscription.cache &&
-            existingSubscription.lastData !== undefined &&
-            subscriptionOptions.onData) {
-            setTimeout(() => {
-                var _a;
-                (_a = subscriptionOptions.onData) === null || _a === void 0 ? void 0 : _a.call(subscriptionOptions, addIdsToSubscriptionData(existingSubscription.lastData));
-            }, 0);
+        let refreshPromise = null;
+        if (responseCacheEnabled) {
+            // Explicit, principal-bound cache opt-in may replay exactly one
+            // snapshot. Prefer the active subscription's lastData, falling back
+            // to the short-lived response cache while a reconnect is in flight.
+            if (replayData !== undefined && replayOnData) {
+                setTimeout(() => {
+                    replayOnData === null || replayOnData === void 0 ? void 0 : replayOnData(addIdsToSubscriptionData(replayData));
+                }, 0);
+            }
+        }
+        else {
+            // Default (non-cache) subscriptions require a fresh authorized
+            // baseline for every newly joined callback. Reuse the same logical
+            // subscription id and socket, but make the server re-run the read.
+            refreshPromise = requestFreshSubscriptionSnapshot(connection, existingSubscription, subscriptionOptions);
+        }
+        releaseConnection();
+        if (refreshPromise) {
+            try {
+                await refreshPromise;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                let deliveredLocally = false;
+                if (!err.__boundedDeliveredToOnError) {
+                    deliveredLocally = notifyErrorCallback(subscriptionOptions, err);
+                }
+                if (!subscriptionOptions.onError) {
+                    await removeCallbackFromSubscription(connection, existingSubscription.subscriptionId, subscriptionOptions);
+                    throw err;
+                }
+                if (!err.__boundedDeliveredToOnError && !deliveredLocally) {
+                    console.warn('[WS v2] Subscription refresh failed, keeping for reconnect recovery:', error);
+                }
+            }
         }
         return async () => {
             await removeCallbackFromSubscription(connection, existingSubscription.subscriptionId, subscriptionOptions);
         };
     }
+    // Deliver cached data immediately for a new logical subscription, but only
+    // after connection auth preflight has succeeded. An expired authenticated
+    // session must receive an auth error, not a stale private snapshot followed
+    // by a failed connect.
+    if (cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL && subscriptionOptions.onData) {
+        setTimeout(() => {
+            var _a;
+            (_a = subscriptionOptions.onData) === null || _a === void 0 ? void 0 : _a.call(subscriptionOptions, addIdsToSubscriptionData(cachedEntry.data));
+        }, 0);
+    }
     // Create new subscription
     const subscriptionId = generateSubscriptionId();
-    const subscription = {
-        subscriptionId,
-        path: normalizedPath,
-        filter: subscriptionOptions.filter,
-        sort: subscriptionOptions.sort,
-        prompt: subscriptionOptions.prompt,
-        shape: subscriptionOptions.shape,
-        limit: subscriptionOptions.limit,
-        cursor: subscriptionOptions.cursor,
-        includeSubPaths: (_b = subscriptionOptions.includeSubPaths) !== null && _b !== void 0 ? _b : false,
-        callbacks: [subscriptionOptions],
-        lastData: undefined,
-        cache: responseCacheEnabled,
-        identity,
-    };
-    connection.subscriptions.set(subscriptionId, subscription);
+    let subscription;
+    try {
+        subscription = {
+            subscriptionId,
+            path: normalizedPath,
+            filter: subscriptionOptions.filter,
+            sort: subscriptionOptions.sort,
+            prompt: subscriptionOptions.prompt,
+            shape: subscriptionOptions.shape,
+            limit: subscriptionOptions.limit,
+            cursor: subscriptionOptions.cursor,
+            includeSubPaths: (_e = subscriptionOptions.includeSubPaths) !== null && _e !== void 0 ? _e : false,
+            callbacks: [subscriptionOptions],
+            lastData: undefined,
+            dataRevision: 0,
+            refresh: null,
+            cache: responseCacheEnabled,
+            identity,
+            identityToken,
+            specKey,
+        };
+        connection.subscriptions.set(subscriptionId, subscription);
+    }
+    catch (error) {
+        releaseConnection();
+        throw error;
+    }
+    releaseConnection();
     // Send subscribe message if connected
     if (connection.isConnected && !connection.isAuthenticating) {
         // Create a promise to wait for subscription confirmation
@@ -6532,15 +7613,23 @@ async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
+            let deliveredLocally = false;
             if (!err.__boundedDeliveredToOnError) {
-                notifyErrorCallbacks(subscription, err);
+                // A local confirmation timeout belongs to the caller that
+                // originated it. Joined callbacks may already have a viable
+                // same-id refresh and must not be poisoned by that old attempt.
+                deliveredLocally = notifyErrorCallback(subscriptionOptions, err);
             }
             if (!subscriptionOptions.onError) {
                 connection.pendingSubscriptions.delete(subscriptionId);
-                connection.subscriptions.delete(subscriptionId);
+                // This registration may have acquired joined callbacks while
+                // its confirmation was pending. Remove only the originating
+                // callback; deleting the whole logical subscription would
+                // orphan those remounted consumers and their refresh flight.
+                await removeCallbackFromSubscription(connection, subscriptionId, subscriptionOptions);
                 throw err;
             }
-            if (!err.__boundedDeliveredToOnError) {
+            if (!err.__boundedDeliveredToOnError && !deliveredLocally) {
                 console.warn('[WS v2] Subscription confirmation failed, keeping for reconnect recovery:', error);
             }
         }
@@ -6551,12 +7640,14 @@ async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
     };
 }
 async function removeCallbackFromSubscription(connection, subscriptionId, callback) {
+    var _a;
     const subscription = connection.subscriptions.get(subscriptionId);
     if (!subscription) {
         return;
     }
     // Remove this callback
     subscription.callbacks = subscription.callbacks.filter(cb => cb !== callback);
+    (_a = subscription.refresh) === null || _a === void 0 ? void 0 : _a.callbacks.delete(callback);
     // If there are still callbacks, don't unsubscribe
     if (subscription.callbacks.length > 0) {
         return;
@@ -6578,17 +7669,9 @@ async function removeCallbackFromSubscription(connection, subscriptionId, callba
         sendUnsubscribe(connection, subscriptionId);
         await unsubscribePromise;
     }
-    // If no more subscriptions, close connection
-    if (connection.subscriptions.size === 0 && connection.ws) {
-        // Clear token refresh timer
-        if (connection.tokenRefreshTimer) {
-            clearInterval(connection.tokenRefreshTimer);
-            connection.tokenRefreshTimer = null;
-        }
-        connection.ws.close();
-        connection.ws = null;
-        connections.delete(connection.key);
-    }
+    // If no more subscriptions, let the connection close after a short idle
+    // grace so an immediately-following route remount can reclaim the socket.
+    scheduleConnectionCloseIfIdle(connection);
 }
 /**
  * Close all v2 subscriptions.
@@ -6596,6 +7679,11 @@ async function removeCallbackFromSubscription(connection, subscriptionId, callba
 async function closeAllSubscriptionsV2() {
     const closePromises = [];
     for (const [appId, connection] of connections) {
+        cancelIdleConnectionClose(connection);
+        const closeError = new Error('Subscriptions closed');
+        for (const subscription of connection.subscriptions.values()) {
+            rejectSubscriptionRefresh(subscription, closeError);
+        }
         if (connection.tokenRefreshTimer) {
             clearInterval(connection.tokenRefreshTimer);
             connection.tokenRefreshTimer = null;
@@ -6604,15 +7692,18 @@ async function closeAllSubscriptionsV2() {
             const ws = connection.ws;
             connection.ws = null;
             connection.isConnected = false;
-            closePromises.push(new Promise((resolve) => {
-                ws.addEventListener('close', () => {
-                    resolve();
-                });
-                ws.close();
-            }));
+            if (ws.readyState !== WS_READY_STATE_CLOSED) {
+                closePromises.push(new Promise((resolve) => {
+                    ws.addEventListener('close', () => {
+                        resolve();
+                    });
+                    ws.close();
+                }));
+            }
         }
         connections.delete(appId);
     }
+    connectionAcquisitions.clear();
     await Promise.all(closePromises);
 }
 /**
@@ -6645,10 +7736,12 @@ function getCachedDataV2(path, prompt) {
     // opt-in. Resolve the caller's identity from an active cache-enabled
     // subscription for this path. No matching sub → null (safe).
     let identity;
+    let identityToken;
     outer: for (const connection of connections.values()) {
         for (const sub of connection.subscriptions.values()) {
             if (sub.cache && sub.path === normalizedPath && sub.prompt === prompt) {
                 identity = sub.identity;
+                identityToken = sub.identityToken;
                 break outer;
             }
         }
@@ -6657,7 +7750,7 @@ function getCachedDataV2(path, prompt) {
         return null;
     }
     const cacheKey = getCacheKey(path, prompt, undefined, undefined, undefined, undefined, identity);
-    const cachedEntry = responseCache.get(cacheKey);
+    const cachedEntry = getResponseCacheEntry(cacheKey, identityToken !== null && identityToken !== void 0 ? identityToken : null);
     if (cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL) {
         return cachedEntry.data;
     }
@@ -6719,10 +7812,15 @@ async function doReconnectWithNewAuth() {
         if (!connection.ws) {
             continue;
         }
+        cancelIdleConnectionClose(connection);
+        const reconnectError = new Error('Connection reconnecting due to auth change');
         for (const [, pending] of connection.pendingSubscriptions) {
-            pending.reject(new Error('Connection reconnecting due to auth change'));
+            pending.reject(reconnectError);
         }
         connection.pendingSubscriptions.clear();
+        for (const subscription of connection.subscriptions.values()) {
+            rejectSubscriptionRefresh(subscription, reconnectError);
+        }
         for (const [, pending] of connection.pendingUnsubscriptions) {
             pending.resolve();
         }
@@ -6782,10 +7880,10 @@ async function wsIntent(appId, roomRoutePath, intent, isServer) {
     const currentToken = await getIdToken(isServer).catch(() => null);
     if (!currentToken) {
         // Mid-refresh: the socket principal still governs server-side.
-        if (!connection.authTokenFingerprint && !connection.authPrincipal)
+        if (!connection.authTokenValue && !connection.authPrincipal)
             return false;
     }
-    else if (!connection.authTokenFingerprint && !connection.authPrincipal) {
+    else if (!connection.authTokenValue && !connection.authPrincipal) {
         // Anonymous socket + authenticated user: do not attribute this user's
         // input to the anon principal. Reauth the socket; caller may fall back.
         void maybeReauthRoomConnection(connection);
@@ -6805,7 +7903,7 @@ async function wsIntent(appId, roomRoutePath, intent, isServer) {
     }
 }
 // Debounced background reauth: when the client's current token no longer
-// matches the connection's auth fingerprint (token rotation), refresh the
+// matches the connection's authenticated identity (token rotation), refresh the
 // socket auth ONCE rather than degrading every subsequent send.
 const reauthInFlight = new WeakSet();
 async function maybeReauthRoomConnection(connection, isServer) {
@@ -7488,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;
@@ -7498,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;
@@ -7511,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;
@@ -7528,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;
@@ -7548,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;