@bounded-sh/core 0.0.41 → 0.0.44

package/dist/index.mjs

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