@bounded-sh/core 0.0.68 → 0.0.70

package/dist/{index-C9w7qQpj.js → index-CqTl6vHg.js}

@@ -687,8 +687,8 @@ function refreshedTokenMayReplaceStored(newIdToken, storedAddress, decodeBase64U
  * event bus, so a session dying inside a session manager used to be invisible to
  * the SDK: `setCurrentUser(null)` was only ever called by `logout()` and `init()`.
  * The result was a UI that kept showing a connected wallet long after the session
- * it was showing had been wiped, which is exactly what let the Solana lab freeze a
- * review against a wallet the server no longer knew about.
+ * it was showing had been wiped, which is exactly what let a wallet-review UI
+ * freeze a review against a wallet the server no longer knew about.
  *
  * `js-sdk` registers a handler at init; core fires it ONLY when storage was
  * actually cleared, never on a failed-but-preserved refresh. Firing on a
@@ -4045,7 +4045,7 @@ class ServerSessionManager {
         const sessionConfig = (_a = this.sessionConfig) !== null && _a !== void 0 ? _a : undefined;
         /* fetch nonce from auth API (bound to the snapshotted app+issuer) */
         const nonce = await genAuthNonce(sessionConfig);
-        const { genSolanaMessage } = await Promise.resolve().then(function () { return require('./solana-message-DibkzgkZ.js'); });
+        const { genSolanaMessage } = await Promise.resolve().then(function () { return require('./solana-message-BecAT47y.js'); });
         const message = await genSolanaMessage(address, nonce, sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.appId);
         /* sign the message */
         const sigBytes = nacl.sign.detached(new TextEncoder().encode(message), kp.secretKey);
@@ -5406,6 +5406,35 @@ async function getWsAuthToken(isServer) {
         throw rememberAmbientAuthFailure(normalizeAuthExpiredError(error, 'Authentication expired and refresh failed'));
     }
 }
+/**
+ * The server refused the token sent on the auth frame: its error frame arrives
+ * while the auth ack is still pending, just before the 1008 close. Local expiry
+ * had vouched for that exact token (unexpired but invalid - e.g. a rotated
+ * issuer key), so re-sending it would only be refused again. Force a genuinely
+ * new one: a definitive issuer rejection clears the session inside the shared
+ * helper (firing notifySessionCleared, which signs the UI out), a successful
+ * refresh commits a new token - and the ordinary reconnect loop picks up either
+ * outcome on its own. Fresh token: authenticates. No token: connects
+ * anonymously and public reads replay instead of erroring forever.
+ */
+async function recoverFromServerAuthRejection(connection) {
+    const rejected = connection.pendingAuthToken;
+    if (!rejected)
+        return;
+    // One forced refresh per distinct rejected token value: a transiently
+    // unreachable issuer must not turn the reconnect loop into a refresh storm.
+    if (connection.serverRejectedAuthToken === rejected)
+        return;
+    connection.serverRejectedAuthToken = rejected;
+    try {
+        await getFreshAuthToken(connection.isServer, { force: true });
+    }
+    catch (_a) {
+        // Every failure mode is already handled inside the helper: a dead
+        // session was cleared (auth listeners notified), a transient refresh
+        // failure keeps the session and the latch above stops the storm.
+    }
+}
 async function getConnectionAuthToken(isServer, authTokenProvider, anonymous) {
     // A read-only scoped instance connects anonymously: no auth frame, and it
     // must never read (or refresh) the ambient global session - that session
@@ -5729,6 +5758,8 @@ async function getOrCreateConnectionOnce(appId, isServer, routePath, authTokenPr
         authFailure: null,
         source,
         anonymous,
+        isServer,
+        serverRejectedAuthToken: null,
     };
     connections.set(connKey, connection);
     // URL provider for reconnection with fresh tokens
@@ -5994,6 +6025,16 @@ function handleServerMessage(connection, message) {
         }
         case 'error': {
             console.error('[WS v2] Server error:', message.code, message.message);
+            // The auth frame was just refused: while the auth ack is pending the
+            // server sends no other error frame, and this one is immediately
+            // followed by its 1008 close. Kick the forced-refresh recovery - the
+            // ordinary reconnect loop then re-auths with a fresh token or, once a
+            // definitively dead session is cleared, connects anonymously so
+            // public reads still replay. Ambient connections only: wallet-scoped
+            // connections refresh through their own provider.
+            if (connection.isAuthenticating && connection.pendingAuthToken && !connection.authTokenProvider && !connection.anonymous) {
+                void recoverFromServerAuthRejection(connection);
+            }
             // Build an Error that ALSO carries the stable `code` as a structured
             // field (not just string-interpolated into the message) so callers can
             // branch on it — e.g. `catch (e) { if (e.code === 'invariant_violation') }`
@@ -6777,7 +6818,7 @@ async function doReconnectWithNewAuth() {
         console.warn('[WS v2] Failed to clear HTTP read cache on auth change:', error);
     }
     try {
-        const { reconnectRealtimeStoreWithNewAuth } = await Promise.resolve().then(function () { return require('./realtime-store-CQiij3zc.js'); });
+        const { reconnectRealtimeStoreWithNewAuth } = await Promise.resolve().then(function () { return require('./realtime-store-DfeKV55-.js'); });
         await reconnectRealtimeStoreWithNewAuth();
     }
     catch (error) {
@@ -6888,7 +6929,7 @@ async function runNamedQueriesOverSocket(appId, queries, isServer) {
         return null; // timeout / disconnect / server error frame -> HTTP re-runs authoritatively
     }
     if ((data === null || data === void 0 ? void 0 : data.useHttp) === true)
-        return null; // server deferred (onchain/EVM, cross-room, malformed)
+        return null; // server deferred (onchain, cross-room, malformed)
     if (Array.isArray(data === null || data === void 0 ? void 0 : data.queries))
         return data.queries;
     return null; // unexpected shape -> HTTP
@@ -7001,456 +7042,6 @@ async function wsIntentReliable(appId, roomRoutePath, intent, isServer) {
     });
 }
 
-/**
- * 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);
-    }
-}
-
 /**
  * Thrown when a user's wallet doesn't have enough SOL to cover the transaction.
  * Apps can catch this to trigger an onramp/funding flow.
@@ -8566,12 +8157,12 @@ async function set(path, document, options) {
  * state appears only under `observation`/`mirrorSync` once actually observed.
  */
 async function setMany(many, options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     // Returns the data that was set, or undefined if the document was already set.
     try {
         // A server WalletClient threads its immutable config snapshot; the default
         // path reads the mutable process-global init() config. This keeps the app-id
-        // bound into an on-chain 202 write (EVM/Solana/offchain) on the wallet
+        // bound into an on-chain 202 write (Solana/offchain) on the wallet
         // client's original app after a later global init() (CTA-05).
         const config = (_b = (_a = options === null || options === void 0 ? void 0 : options._overrides) === null || _a === void 0 ? void 0 : _a._config) !== null && _b !== void 0 ? _b : await getConfig();
         const authProvider = (_d = (_c = options === null || options === void 0 ? void 0 : options._overrides) === null || _c === void 0 ? void 0 : _c.authProvider) !== null && _d !== void 0 ? _d : config.authProvider;
@@ -8640,13 +8231,18 @@ 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;
+            // The EVM onchain data plane is retired: no worker mints an EVM 202 any
+            // more. A payload that still carries one is an unexpected response and
+            // fails loudly BEFORE anything is signed - never silently ignored.
+            if ((curTx === null || curTx === void 0 ? void 0 : curTx.evmTransaction) != null) {
+                throw new Error('Unsupported 202 transaction shape: the write response carried an evmTransaction, ' +
+                    'but EVM onchain writes are no longer supported. Nothing was signed or submitted.');
+            }
             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');
+            if (hasSerializedSolanaTarget && hasBuiltSolanaTarget) {
+                throw new Error('Ambiguous on-chain write response mixes Solana transaction target formats');
             }
             const expectedWritePaths = documents.map(d => d.destinationPath);
             const requestedDocuments = buildRequestedDocuments(documents);
@@ -8659,67 +8255,13 @@ async function setMany(many, options) {
                 throw new Error('The write response carried no execution-chain tag, so this receipt could not state where the write ran. ' +
                     'Nothing was signed or submitted.');
             }
-            // 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: (_o = (_m = (_l = options === null || options === void 0 ? void 0 : options._overrides) === null || _l === void 0 ? void 0 : _l._evmTransactionPolicy) !== null && _m !== void 0 ? _m : config.evmWalletConfig) !== null && _o !== void 0 ? _o : null,
-                });
-                const evmChain = workerChain;
-                const evmOutcome = await handleEvmTransaction(curTx.evmTransaction, authProvider, options);
-                // CAPTURE THE RECEIPT FIRST. Mirror synchronization comes after, and its
-                // failure can never turn a landed transaction into a thrown error that
-                // invites the caller to submit the same write twice.
-                if (evmOutcome.outcome === 'confirmed') {
-                    const mirrorSync = await attemptMirrorSync(expectedWritePaths, options);
-                    return {
-                        status: 'confirmed', appId, requestedDocuments, chain: evmChain,
-                        transactionId: evmOutcome.transactionSignature,
-                        blockNumber: evmOutcome.blockNumber,
-                        mirrorSync,
-                    };
-                }
-                // An unknown confirmation outcome is NOT a mirror question: nothing is
-                // known to have landed, so no synchronization is attempted.
-                if (evmOutcome.transactionSignature === null) {
-                    return {
-                        status: 'submitted', appId, requestedDocuments, chain: evmChain,
-                        transactionId: null,
-                        confirmation: { state: 'unknown', reason: evmOutcome.reason, reconcilable: false },
-                    };
-                }
-                if ('fence' in evmOutcome && evmOutcome.fence) {
-                    return {
-                        status: 'submitted', appId, requestedDocuments, chain: evmChain,
-                        transactionId: evmOutcome.transactionSignature,
-                        fence: evmOutcome.fence,
-                        confirmation: { state: 'unknown', reason: evmOutcome.reason },
-                    };
-                }
-                return {
-                    status: 'submitted', appId, requestedDocuments, chain: evmChain,
-                    transactionId: evmOutcome.transactionSignature,
-                    rebroadcastable: false,
-                    confirmation: { state: 'unknown', reason: evmOutcome.reason },
-                };
-            }
-            else if (curTx.serializedTransaction) {
+            if (curTx.serializedTransaction) {
                 if (!SOLANA_CHAIN_TAGS.has(workerChain)) {
                     throw new Error(`The write response reported execution chain "${workerChain}" for a Solana transaction. ` +
                         'Nothing was signed or submitted.');
                 }
                 const solanaChain = workerChain;
-                const { handlePreBuiltTransaction } = await Promise.resolve().then(function () { return require('./solana-operations-XjBhPOnu.js'); });
+                const { handlePreBuiltTransaction } = await Promise.resolve().then(function () { return require('./solana-operations-uN89eqO2.js'); });
                 const solanaOutcome = await handlePreBuiltTransaction(curTx, authProvider, options, expectedWritePaths);
                 // `shouldSubmitTx: false` signed WITHOUT sending — no signature exists,
                 // and there is nothing to mirror, so no synchronization is attempted.
@@ -8753,7 +8295,7 @@ async function setMany(many, options) {
                 };
             }
             else {
-                throw new Error('Unsupported 202 transaction shape: expected serializedTransaction or evmTransaction');
+                throw new Error('Unsupported 202 transaction shape: expected serializedTransaction');
             }
         }
         else if (setResponse.status === 200) {
@@ -8774,7 +8316,7 @@ async function setMany(many, options) {
                 observation: observationFromDirectCommit(documents.map(d => d.destinationPath), receipt === null || receipt === void 0 ? void 0 : receipt.observation),
                 // A worker predating the batch receipt reports no lane. Say so rather
                 // than inventing one — and never discard a committed write's receipt.
-                chain: ((_p = readWorkerChainTag(receipt)) !== null && _p !== void 0 ? _p : 'unknown'),
+                chain: ((_l = readWorkerChainTag(receipt)) !== null && _l !== void 0 ? _l : 'unknown'),
                 transactionId: typeof rawTransactionId === 'string' && rawTransactionId.length > 0 ? rawTransactionId : null,
             };
         }
@@ -8785,18 +8327,6 @@ async function setMany(many, options) {
     catch (error) {
         throw error;
     }
-    // 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) {
-        const result = await authProvider.runTransaction(evmTransaction, undefined, options);
-        if ((result === null || result === void 0 ? void 0 : result.lane) !== 'evm') {
-            throw new Error('The EVM auth provider returned a non-EVM transaction outcome');
-        }
-        return result;
-    }
 }
 /**
  * Extract the document/collection path from a cache key. Keys are
@@ -9050,7 +8580,6 @@ var operations = /*#__PURE__*/Object.freeze({
 const DEFAULT_TIMEOUT_MS = 60000;
 const DEFAULT_MAX_ATTEMPTS = 20;
 const DEFAULT_POLL_INTERVAL_MS = 3000;
-const DEFAULT_MIN_REBROADCAST_INTERVAL_MS = 15000;
 /** Mirror read after a late confirmation. No settle delay: the tx already landed. */
 const RECONCILE_MIRROR_SETTLE_MS = 0;
 function errorText(error) {
@@ -9060,12 +8589,6 @@ function errorText(error) {
 function isSolanaSubmitted(receipt) {
     return receipt.status === 'submitted' && 'signedTransaction' in receipt;
 }
-function isEvmFencedSubmitted(receipt) {
-    return receipt.status === 'submitted' && 'fence' in receipt && !('signedTransaction' in receipt);
-}
-function isEvmHashKnownSubmitted(receipt) {
-    return receipt.status === 'submitted' && receipt.rebroadcastable === false;
-}
 /**
  * The Solana execution lane a client config REQUIRES, or `null` when the config
  * carries no constraint. Only a positive contradiction rejects a receipt — an
@@ -9090,7 +8613,6 @@ function requiredSolanaChain(config) {
  * a global re-`init()` could otherwise poll the wrong app's endpoints entirely.
  */
 function assertReceiptMatchesContext(receipt, config) {
-    var _a;
     if (!receipt.appId || typeof receipt.appId !== 'string') {
         throw new Error('This write receipt carries no appId and cannot be reconciled.');
     }
@@ -9103,22 +8625,6 @@ function assertReceiptMatchesContext(receipt, config) {
         if (required && required !== receipt.chain) {
             throw new Error(`This write receipt ran on "${receipt.chain}" but the bound client targets "${required}".`);
         }
-        return;
-    }
-    const fence = receipt.fence;
-    if (fence && typeof fence.chainId === 'number') {
-        const evm = config.evmWalletConfig;
-        const configured = new Set();
-        if (evm && typeof evm.chainId === 'number')
-            configured.add(evm.chainId);
-        for (const id of Object.keys((_a = evm === null || evm === void 0 ? void 0 : evm.runtimeAddresses) !== null && _a !== void 0 ? _a : {})) {
-            const parsed = Number(id);
-            if (Number.isSafeInteger(parsed))
-                configured.add(parsed);
-        }
-        if (configured.size > 0 && !configured.has(fence.chainId)) {
-            throw new Error(`This write receipt ran on EVM chain ${fence.chainId}, which the bound client does not configure.`);
-        }
     }
 }
 function stillSubmitted(receipt, reason) {
@@ -9235,67 +8741,18 @@ async function reconcileSolana(receipt, config, options) {
     };
 }
 /**
- * EVM reconciliation runs through the provider's own transport, so a wallet
- * client reconciles with its own identity and RPC. There is deliberately NO
- * EVM retry-safe terminal state: nonce advancement is not proof the write did
- * not execute, and plain JSON-RPC offers no transaction-by-sender-and-nonce
- * lookup, so a `submitted` EVM receipt either confirms or stays `submitted`.
- */
-async function reconcileEvm(receipt, provider, options) {
-    if (!provider || typeof provider.reconcileEvmTransaction !== 'function') {
-        return stillSubmitted(receipt, 'no EVM reconciliation transport is available on the bound auth provider');
-    }
-    const fenced = isEvmFencedSubmitted(receipt) ? receipt.fence : undefined;
-    const allowRebroadcast = Boolean(fenced) && (options === null || options === void 0 ? void 0 : options.allowRebroadcast) !== false;
-    let outcome;
-    try {
-        outcome = await provider.reconcileEvmTransaction({
-            transactionHash: receipt.transactionId,
-            fence: fenced,
-            allowRebroadcast,
-        });
-    }
-    catch (error) {
-        return stillSubmitted(receipt, `EVM reconciliation failed: ${errorText(error)}`);
-    }
-    if (outcome.state === 'failed') {
-        // Landed and reverted: a genuine failure, never `submitted`.
-        throw new Error(outcome.reason);
-    }
-    if (outcome.state === 'confirmed') {
-        if (typeof outcome.blockNumber !== 'number') {
-            return stillSubmitted(receipt, 'the EVM receipt reported success without a block number, so confirmation could not be stated');
-        }
-        const confirmed = {
-            status: 'confirmed',
-            appId: receipt.appId,
-            requestedDocuments: receipt.requestedDocuments,
-            chain: receipt.chain,
-            transactionId: receipt.transactionId,
-            blockNumber: outcome.blockNumber,
-            mirrorSync: await mirrorFor(receipt, options),
-        };
-        return confirmed;
-    }
-    if (outcome.state === 'absent_after_expiry') {
-        // Defensive: no EVM lane may report a retry-safe terminal state.
-        return stillSubmitted(receipt, 'the EVM transport reported absence, which is not proof an EVM write did not execute');
-    }
-    return stillSubmitted(receipt, outcome.reason);
-}
-/**
- * Poll the SAME signature/hash a `submitted` receipt carries and return the
+ * Poll the SAME signature a `submitted` receipt carries and return the
  * resulting `SetResult`.
  *
  * - Terminal receipts (`committed`, `confirmed`, `expired_not_landed`,
  *   `signed`) are returned unchanged; nothing was left open.
- * - An irreconcilable injected-wallet receipt (`transactionId: null`) is
- *   rejected immediately: no identifier exists to poll.
+ * - A `submitted` receipt with no transaction identifier (`transactionId:
+ *   null`) is rejected immediately: no identifier exists to poll.
  * - A transaction that landed and FAILED throws, exactly as it would have on
  *   the original write.
  */
 async function reconcileSetResult(receipt, options) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b;
     if (!receipt || typeof receipt !== 'object' || typeof receipt.status !== 'string') {
         throw new Error('reconcileSetResult requires a write receipt returned by set/setMany.');
     }
@@ -9311,23 +8768,21 @@ async function reconcileSetResult(receipt, options) {
     if (isSolanaSubmitted(receipt)) {
         return reconcileSolana(receipt, config, options);
     }
-    const provider = (_e = (_d = (_c = options === null || options === void 0 ? void 0 : options._overrides) === null || _c === void 0 ? void 0 : _c.authProvider) !== null && _d !== void 0 ? _d : config.authProvider) !== null && _e !== void 0 ? _e : null;
-    if (isEvmFencedSubmitted(receipt) || isEvmHashKnownSubmitted(receipt)) {
-        return reconcileEvm(receipt, provider, options);
-    }
+    // Anything else (e.g. a legacy serialized receipt from a retired lane) has no
+    // reconciliation transport any more; say so rather than guessing.
     return stillSubmitted(receipt, 'this receipt shape has no reconciliation lane');
 }
 /**
  * Reconcile repeatedly until the receipt leaves `submitted` or the bound is hit.
  *
  * The bound is mandatory, because some states are permanently non-terminal by
- * design: an unidentified nonce consumer or a permanently underpriced EVM
- * transaction never resolves. On exhaustion (or abort) this returns the LATEST
- * `submitted` receipt with its identifier intact rather than hanging or
- * throwing the identifier away.
+ * design: an RPC that can never observe the signature or the expiry never
+ * resolves. On exhaustion (or abort) this returns the LATEST `submitted`
+ * receipt with its identifier intact rather than hanging or throwing the
+ * identifier away.
  */
 async function waitForSetResult(receipt, options) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     if (receipt && typeof receipt === 'object' && receipt.status === 'submitted' && receipt.transactionId === null) {
         // Rejected immediately rather than polled: there is nothing to poll.
         return reconcileSetResult(receipt, options);
@@ -9335,21 +8790,14 @@ async function waitForSetResult(receipt, options) {
     const timeoutMs = (_a = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT_MS;
     const maxAttempts = (_b = options === null || options === void 0 ? void 0 : options.maxAttempts) !== null && _b !== void 0 ? _b : DEFAULT_MAX_ATTEMPTS;
     const pollIntervalMs = (_c = options === null || options === void 0 ? void 0 : options.pollIntervalMs) !== null && _c !== void 0 ? _c : DEFAULT_POLL_INTERVAL_MS;
-    const minRebroadcastIntervalMs = (_d = options === null || options === void 0 ? void 0 : options.minRebroadcastIntervalMs) !== null && _d !== void 0 ? _d : DEFAULT_MIN_REBROADCAST_INTERVAL_MS;
-    const rebroadcastPermitted = (options === null || options === void 0 ? void 0 : options.allowRebroadcast) !== false;
     const startedAt = Date.now();
     let current = receipt;
     let attempts = 0;
-    let lastRebroadcastAt = -Infinity;
     while (attempts < maxAttempts && Date.now() - startedAt < timeoutMs) {
-        if ((_e = options === null || options === void 0 ? void 0 : options.signal) === null || _e === void 0 ? void 0 : _e.aborted)
+        if ((_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.aborted)
             return current;
-        const now = Date.now();
-        const allowRebroadcast = rebroadcastPermitted && (now - lastRebroadcastAt >= minRebroadcastIntervalMs);
-        if (allowRebroadcast)
-            lastRebroadcastAt = now;
         attempts++;
-        current = await reconcileSetResult(current, Object.assign(Object.assign({}, options), { allowRebroadcast }));
+        current = await reconcileSetResult(current, options);
         if (current.status !== 'submitted')
             return current;
         if (attempts >= maxAttempts)
@@ -10254,7 +9702,7 @@ function toMillis(seconds) {
 
 /** SIWS message creation is async already, so its onchain module can be lazy. */
 async function genSolanaMessage(address, nonce) {
-    const implementation = await Promise.resolve().then(function () { return require('./solana-message-DibkzgkZ.js'); });
+    const implementation = await Promise.resolve().then(function () { return require('./solana-message-BecAT47y.js'); });
     return implementation.genSolanaMessage(address, nonce);
 }
 
@@ -10731,8 +10179,6 @@ function defineLiveModule(mod) {
 
 exports.AUTH_CHANGED_CODE = AUTH_CHANGED_CODE;
 exports.AUTH_EXPIRED_CODE = AUTH_EXPIRED_CODE;
-exports.BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR = BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR;
-exports.BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR = BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR;
 exports.BoundedDeclineError = BoundedDeclineError;
 exports.DECLINE_EVENT_NAME = DECLINE_EVENT_NAME;
 exports.DEFAULT_QUERY_POLL_INTERVAL_MS = DEFAULT_QUERY_POLL_INTERVAL_MS;
@@ -10749,8 +10195,6 @@ exports.SessionEnvironmentError = SessionEnvironmentError;
 exports.UNSUPPORTED_ENVIRONMENT_CODE = UNSUPPORTED_ENVIRONMENT_CODE;
 exports.WebSessionManager = WebSessionManager;
 exports.aggregate = aggregate;
-exports.assertCanonicalBoundedRuntimeWriteCalldata = assertCanonicalBoundedRuntimeWriteCalldata;
-exports.assertEvmTransactionMatchesWrite = assertEvmTransactionMatchesWrite;
 exports.bufferExports = bufferExports;
 exports.canonicalizeArgs = canonicalizeArgs;
 exports.canonicalizeResult = canonicalizeResult;
@@ -10819,4 +10263,4 @@ exports.toMillis = toMillis;
 exports.toSeconds = toSeconds;
 exports.waitForSetResult = waitForSetResult;
 exports.withEffects = withEffects;
-//# sourceMappingURL=index-C9w7qQpj.js.map
+//# sourceMappingURL=index-CqTl6vHg.js.map