@bounded-sh/core 0.0.115 → 0.0.117-sync.0

package/dist/client/operations.d.ts

@@ -283,12 +283,12 @@ export declare function runExpressionMany(many: {
     _overrides?: RequestOverrides;
 }[]): Promise<RunExpressionResult[]>;
 /**
- * Best-effort mirror read. A confirmed transaction must NEVER be lost to a
+ * Best-effort chain synchronization. A confirmed transaction must NEVER be lost to a
  * synchronization failure, so this reports its outcome in `mirrorSync` and
- * never rejects. It reads the CONCRETE destination paths, so a collection
- * insert with a generated id syncs the path that actually exists.
+ * never rejects. The signature lets the server index the exact transaction,
+ * including hook-mutated documents beyond the requested destination paths.
  */
-export declare function attemptMirrorSync(paths: string[], options?: SetOptions, settleMs?: number): Promise<MirrorSync>;
+export declare function attemptMirrorSync(paths: string[], options?: SetOptions, transactionSignature?: string): Promise<MirrorSync>;
 /**
  * Write a document at `path`. Sugar for a one-element {@link setMany}.
  *
@@ -395,4 +395,5 @@ export declare function setFile(path: string, file: File | null, options?: {
 export declare function signMessage(message: string): Promise<string>;
 export declare function signTransaction(transaction: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
 export declare function signAndSubmitTransaction(transaction: Transaction | VersionedTransaction, feePayer?: PublicKey): Promise<string>;
-export declare function syncItems(paths: string[], options?: SetOptions): Promise<any>;
+/** Refresh concrete paths, or index a confirmed transaction and read its requested paths. */
+export declare function syncItems(paths: string[], options?: SetOptions, transactionSignature?: string): Promise<any>;

package/dist/{index-5TMFraRK.js → index-BcJOeks0.js}

@@ -826,6 +826,63 @@ function notifySessionCleared() {
     }
 }
 
+// Same-tab session change signal.
+//
+// A page can run more than one copy of the SDK: the app's own bundle and the hosted widget
+// bounded-router injects (which bundles its own, pinned copy). They share one session record in
+// localStorage, keyed by issuer and app id, but the browser fires `storage` events only in OTHER
+// tabs, so a copy that signs in never tells the other copy in the same tab. Until a reload, the
+// app stayed signed out after a widget sign-in and the widget stayed signed out after an app
+// sign-in (observed on staging, 2026-10-07).
+//
+// This announces "the record changed" on a BroadcastChannel, which reaches every other channel
+// on the origin, same tab included, and never the announcing instance itself. The message is a
+// nudge, not an authority: it carries no token and no identity, and a listener only re-reads the
+// record through its ordinary restore path. Nothing signs in or out because of the message alone.
+const SESSION_SIGNAL_CHANNEL = "bounded.session";
+let channel;
+function openChannel() {
+    var _a;
+    if (channel !== undefined)
+        return channel;
+    try {
+        channel = typeof BroadcastChannel === "function" ? new BroadcastChannel(SESSION_SIGNAL_CHANNEL) : null;
+        // Node's BroadcastChannel holds the event loop open until closed; a Node consumer (tests,
+        // tarobase-server) must not hang on exit because of a nudge channel. Browsers have no unref.
+        (_a = channel === null || channel === void 0 ? void 0 : channel.unref) === null || _a === void 0 ? void 0 : _a.call(channel);
+    }
+    catch (_b) {
+        channel = null;
+    }
+    return channel;
+}
+/** Tell the other SDK copies on this origin that the session record under `key` changed. */
+function announceSessionChange(key) {
+    const ch = openChannel();
+    if (!ch)
+        return;
+    try {
+        ch.postMessage({ type: "session-changed", key });
+    }
+    catch (_a) {
+        // A closed or unavailable channel loses the nudge; the record itself is unaffected.
+    }
+}
+/** Run `listener` when another SDK copy announces a session change. Returns the unsubscribe. */
+function onSessionChange(listener) {
+    const ch = openChannel();
+    if (!ch)
+        return () => { };
+    const handler = (event) => {
+        const data = event.data;
+        if (!data || data.type !== "session-changed" || typeof data.key !== "string")
+            return;
+        listener(data.key);
+    };
+    ch.addEventListener("message", handler);
+    return () => ch.removeEventListener("message", handler);
+}
+
 /**
  * The one protocol every session-storage mutation goes through.
  *
@@ -1022,6 +1079,7 @@ class WebSessionManager {
     }
     static writeRaw(sessionObj) {
         localStorage.setItem(this.BOUNDED_SESSION_STORAGE_KEY, JSON.stringify(sessionObj));
+        announceSessionChange(this.BOUNDED_SESSION_STORAGE_KEY);
     }
     /**
      * Read the session, stamping a `sessionGeneration` if it predates them.
@@ -1118,6 +1176,7 @@ class WebSessionManager {
                 idToken,
                 refreshToken, appId: currentAppId, sessionGeneration: generation }, (sessionIssuer ? { issuer: sessionIssuer } : {}))));
         });
+        announceSessionChange(storageKey);
         // Adoption can fail after persistence (for example, logout while the
         // provider is loading). Remove only this incomplete login, even if the
         // caller has since switched app configuration or another tab signed in.
@@ -1129,6 +1188,8 @@ class WebSessionManager {
                 localStorage.removeItem(storageKey);
                 return true;
             });
+            if (removed)
+                announceSessionChange(storageKey);
             if (removed)
                 notifySessionCleared();
         };
@@ -1258,8 +1319,10 @@ class WebSessionManager {
         });
         // Only announce a clear that actually happened, so a no-op cannot sign out
         // a UI that was already signed out.
-        if (removed)
+        if (removed) {
             notifySessionCleared();
+            announceSessionChange(key);
+        }
     }
     /**
      * Remove the session only if it is still the one identified by `generation`.
@@ -1284,8 +1347,10 @@ class WebSessionManager {
             localStorage.removeItem(this.BOUNDED_SESSION_STORAGE_KEY);
             return true;
         });
-        if (removed)
+        if (removed) {
             notifySessionCleared();
+            announceSessionChange(this.BOUNDED_SESSION_STORAGE_KEY);
+        }
     }
     /* ------------------------------------------------------------------ */
     /* IS-AUTH                                                            */
@@ -4242,7 +4307,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-BVwD6WVm.js'); });
+        const { genSolanaMessage } = await Promise.resolve().then(function () { return require('./solana-message-CaPunjVI.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);
@@ -4988,6 +5053,7 @@ class BoundedDeclineError extends Error {
 
 const apiClient = axios.create();
 const TRANSIENT_GET_STATUSES = new Set([500, 502, 503, 504]);
+const TRANSIENT_SYNC_STATUSES = new Set([502, 503, 504]);
 const RATE_LIMIT_RETRY_BASE_DELAY_MS = 100;
 /** The window event emitted when the API responds with HTTP 429. */
 const RATE_LIMIT_EVENT_NAME = 'bounded:ratelimit';
@@ -5036,7 +5102,7 @@ function getRateLimitAttempt(error) {
 axiosRetry(apiClient, {
     retries: 2,
     retryCondition: (error) => {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         // A caller cancellation is final. In particular, never turn a route
         // unmount into a fresh GET after its AbortSignal has fired.
         const canceled = axios.isCancel(error)
@@ -5052,15 +5118,27 @@ axiosRetry(apiClient, {
         // safe for every method, including POST requests to the queries API.
         if (((_d = error.response) === null || _d === void 0 ? void 0 : _d.status) === 429)
             return true;
-        // Only retry idempotent GETs. Network failures and the small set of
-        // conventional transient gateway/runtime statuses get two bounded
-        // retries; auth, policy, invariant, and other terminal responses stay final.
-        // Writes are never retried because the server may already have applied
-        // them before the response was lost.
-        if (((_f = (_e = error.config) === null || _e === void 0 ? void 0 : _e.method) === null || _f === void 0 ? void 0 : _f.toLowerCase()) !== 'get')
+        // Sync only indexes existing chain state, so repeating it cannot submit
+        // a second transaction. Keep its retries in this same bounded transport
+        // loop instead of multiplying them with another SDK retry loop.
+        const method = (_f = (_e = error.config) === null || _e === void 0 ? void 0 : _e.method) === null || _f === void 0 ? void 0 : _f.toLowerCase();
+        let isSync = false;
+        if (method === 'put') {
+            try {
+                isSync = new URL(String((_g = error.config) === null || _g === void 0 ? void 0 : _g.url)).pathname === '/items/sync';
+            }
+            catch ( /* An unrecognized URL is never safe to retry. */_m) { /* An unrecognized URL is never safe to retry. */ }
+        }
+        if (isSync) {
+            return axiosRetry.isNetworkError(error)
+                || TRANSIENT_SYNC_STATUSES.has((_j = (_h = error.response) === null || _h === void 0 ? void 0 : _h.status) !== null && _j !== void 0 ? _j : 0);
+        }
+        // Ordinary writes are never retried: a lost response may follow commit.
+        // GET network and selected gateway/runtime failures are safe to repeat.
+        if (method !== 'get')
             return false;
         return axiosRetry.isNetworkError(error)
-            || TRANSIENT_GET_STATUSES.has((_h = (_g = error.response) === null || _g === void 0 ? void 0 : _g.status) !== null && _h !== void 0 ? _h : 0);
+            || TRANSIENT_GET_STATUSES.has((_l = (_k = error.response) === null || _k === void 0 ? void 0 : _k.status) !== null && _l !== void 0 ? _l : 0);
     },
     retryDelay: (retryCount, error) => {
         var _a;
@@ -7601,7 +7679,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-BiChlioj.js'); });
+        const { reconnectRealtimeStoreWithNewAuth } = await Promise.resolve().then(function () { return require('./realtime-store-5vXHb5Br.js'); });
         await reconnectRealtimeStoreWithNewAuth();
     }
     catch (error) {
@@ -8787,12 +8865,6 @@ async function runExpressionMany(many) {
     }
 }
 /* ===================== WRITE RECEIPT HELPERS (W4) ======================== */
-/**
- * Settle delay before the best-effort mirror read on an on-chain write. It is
- * an optimization, not a correctness guarantee: the receipt is captured first
- * and returned regardless of what the mirror read reports.
- */
-const MIRROR_SYNC_SETTLE_MS = 1500;
 const SOLANA_CHAIN_TAGS = new Set(['solana_devnet', 'solana_mainnet']);
 /**
  * Read the execution-lane tag the WORKER reported. The SDK never infers it: a
@@ -8867,16 +8939,14 @@ function validatePathKeyedDocuments(paths, source) {
     return { observed: true, documents };
 }
 /**
- * Best-effort mirror read. A confirmed transaction must NEVER be lost to a
+ * Best-effort chain synchronization. A confirmed transaction must NEVER be lost to a
  * synchronization failure, so this reports its outcome in `mirrorSync` and
- * never rejects. It reads the CONCRETE destination paths, so a collection
- * insert with a generated id syncs the path that actually exists.
+ * never rejects. The signature lets the server index the exact transaction,
+ * including hook-mutated documents beyond the requested destination paths.
  */
-async function attemptMirrorSync(paths, options, settleMs = MIRROR_SYNC_SETTLE_MS) {
+async function attemptMirrorSync(paths, options, transactionSignature) {
     try {
-        if (settleMs > 0)
-            await new Promise(resolve => setTimeout(resolve, settleMs));
-        const synced = await syncItems(paths, options);
+        const synced = await syncItems(paths, options, transactionSignature);
         // The sync endpoint answers `{ data: <path-keyed map>, status }`; a document
         // path always contains a `/`, so a top-level `data` key is never one.
         const map = (synced && typeof synced === 'object' && !Array.isArray(synced) && 'data' in synced)
@@ -9101,7 +9171,7 @@ async function setMany(many, options) {
                     if (typeof curTx.serializedTransaction !== 'string' || typeof curTx.poofnetIntentId !== 'string') {
                         throw new Error('Unsupported 202 transaction shape: a poofnet write needs serializedTransaction and poofnetIntentId');
                     }
-                    const { signPoofnetTransaction, buildExpectedWriteIntent } = await Promise.resolve().then(function () { return require('./solana-operations-B3u6Arbf.js'); });
+                    const { signPoofnetTransaction, buildExpectedWriteIntent } = await Promise.resolve().then(function () { return require('./solana-operations-BPOTddBI.js'); });
                     const signedTransaction = await signPoofnetTransaction(curTx.serializedTransaction, authProvider, options, buildExpectedWriteIntent(documents));
                     // Signing-only, exactly as on a real chain: signed and NOT committed.
                     if ((options === null || options === void 0 ? void 0 : options.shouldSubmitTx) === false) {
@@ -9139,7 +9209,7 @@ async function setMany(many, options) {
                             'Nothing was signed or submitted.');
                     }
                     const solanaChain = workerChain;
-                    const { handlePreBuiltTransaction, buildExpectedWriteIntent } = await Promise.resolve().then(function () { return require('./solana-operations-B3u6Arbf.js'); });
+                    const { handlePreBuiltTransaction, buildExpectedWriteIntent } = await Promise.resolve().then(function () { return require('./solana-operations-BPOTddBI.js'); });
                     // OA-0001: derive the expected intent from OUR OWN request (the one
                     // ground truth a tampered builder response cannot change) so the
                     // validator can reject any transaction whose operation semantics
@@ -9180,7 +9250,7 @@ async function setMany(many, options) {
                     // best-effort enrichment reported in `mirrorSync`, never a rejection.
                     const mirrorSync = grantLane
                         ? { observed: false, reason: 'not attempted: a venue grant authorizes only the write' }
-                        : await attemptMirrorSync(requestedPaths, options);
+                        : await attemptMirrorSync(requestedPaths, Object.assign(Object.assign({}, options), { _overrides: Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options._overrides), { _config: config }) }), solanaOutcome.transactionSignature);
                     return {
                         status: 'confirmed', appId, requestedDocuments, chain: solanaChain,
                         transactionId: solanaOutcome.transactionSignature,
@@ -9452,14 +9522,18 @@ async function signAndSubmitTransaction(transaction, feePayer) {
     }
     return config.authProvider.signAndSubmitTransaction(transaction, feePayer);
 }
-async function syncItems(paths, options) {
-    try {
-        const response = await makeApiRequest('PUT', 'items/sync', { paths }, options === null || options === void 0 ? void 0 : options._overrides);
-        return response.data;
-    }
-    catch (error) {
-        throw error;
+/** Refresh concrete paths, or index a confirmed transaction and read its requested paths. */
+async function syncItems(paths, options, transactionSignature) {
+    var _a, _b;
+    const response = await makeApiRequest('PUT', 'items/sync', Object.assign({ paths }, (transactionSignature !== undefined ? { transactionSignature } : {})), options === null || options === void 0 ? void 0 : options._overrides);
+    if (transactionSignature !== undefined && (response.status !== 200
+        || ((_a = response.data) === null || _a === void 0 ? void 0 : _a.synchronized) !== true
+        || ((_b = response.data) === null || _b === void 0 ? void 0 : _b.transactionSignature) !== transactionSignature)) {
+        // An older server's local-read stub can return 200 with stale documents.
+        // Only the matching server acknowledgment proves this transaction was indexed.
+        throw new Error('the synchronization response did not acknowledge the confirmed transaction');
     }
+    return response.data;
 }
 
 var operations = /*#__PURE__*/Object.freeze({
@@ -9492,8 +9566,6 @@ var operations = /*#__PURE__*/Object.freeze({
 const DEFAULT_TIMEOUT_MS = 60000;
 const DEFAULT_MAX_ATTEMPTS$1 = 20;
 const DEFAULT_POLL_INTERVAL_MS = 3000;
-/** Mirror read after a late confirmation. No settle delay: the tx already landed. */
-const RECONCILE_MIRROR_SETTLE_MS = 0;
 function errorText(error) {
     const message = error === null || error === void 0 ? void 0 : error.message;
     return typeof message === 'string' && message.length > 0 ? message : String(error);
@@ -9542,12 +9614,12 @@ function assertReceiptMatchesContext(receipt, config) {
 function stillSubmitted(receipt, reason) {
     return Object.assign(Object.assign({}, receipt), { confirmation: Object.assign(Object.assign({}, receipt.confirmation), { reason }) });
 }
-async function mirrorFor(receipt, options) {
+async function mirrorFor(receipt, config, options) {
     const paths = receipt.requestedDocuments.map(entry => entry.path);
     if (paths.length === 0)
         return { observed: false, reason: 'the receipt carried no requested paths' };
-    const setOptions = (options === null || options === void 0 ? void 0 : options._overrides) ? { _overrides: options._overrides } : undefined;
-    return attemptMirrorSync(paths, setOptions, RECONCILE_MIRROR_SETTLE_MS);
+    const setOptions = { _overrides: Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options._overrides), { _config: config }) };
+    return attemptMirrorSync(paths, setOptions, receipt.transactionId);
 }
 async function resolveSolanaRpc(config, options) {
     var _a, _b;
@@ -9629,7 +9701,7 @@ async function reconcileSolana(receipt, config, options) {
             signedTransaction: receipt.signedTransaction,
             fence: receipt.fence,
             confirmationContextSlot: typeof statusValue.slot === 'number' ? statusValue.slot : (contextSlot !== null && contextSlot !== void 0 ? contextSlot : 0),
-            mirrorSync: await mirrorFor(receipt, options),
+            mirrorSync: await mirrorFor(receipt, config, options),
         };
         return confirmed;
     }
@@ -10983,7 +11055,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-BVwD6WVm.js'); });
+    const implementation = await Promise.resolve().then(function () { return require('./solana-message-CaPunjVI.js'); });
     return implementation.genSolanaMessage(address, nonce);
 }
 
@@ -11545,6 +11617,7 @@ exports.LiveIntentError = LiveIntentError;
 exports.MIN_QUERY_POLL_INTERVAL_MS = MIN_QUERY_POLL_INTERVAL_MS;
 exports.RATE_LIMIT_EVENT_NAME = RATE_LIMIT_EVENT_NAME;
 exports.ReactNativeSessionManager = ReactNativeSessionManager;
+exports.SESSION_SIGNAL_CHANNEL = SESSION_SIGNAL_CHANNEL;
 exports.SOLANA_SIGN_IN_STATEMENT = SOLANA_SIGN_IN_STATEMENT;
 exports.ScopedClientReadOnlyError = ScopedClientReadOnlyError;
 exports.ServerSessionManager = ServerSessionManager;
@@ -11552,6 +11625,7 @@ exports.SessionEnvironmentError = SessionEnvironmentError;
 exports.UNSUPPORTED_ENVIRONMENT_CODE = UNSUPPORTED_ENVIRONMENT_CODE;
 exports.WebSessionManager = WebSessionManager;
 exports.aggregate = aggregate;
+exports.announceSessionChange = announceSessionChange;
 exports.browserSignInDomain = browserSignInDomain;
 exports.bufferExports = bufferExports;
 exports.canonicalizeArgs = canonicalizeArgs;
@@ -11602,6 +11676,7 @@ exports.live = live;
 exports.markWriteNotApplied = markWriteNotApplied;
 exports.normalizeEvmAddress = normalizeEvmAddress;
 exports.now = now;
+exports.onSessionChange = onSessionChange;
 exports.onSessionCleared = onSessionCleared;
 exports.queryAggregate = queryAggregate;
 exports.reconcileSetResult = reconcileSetResult;
@@ -11633,4 +11708,4 @@ exports.toSeconds = toSeconds;
 exports.waitForSetResult = waitForSetResult;
 exports.withEffects = withEffects;
 exports.writeNotAppliedPhase = writeNotAppliedPhase;
-//# sourceMappingURL=index-5TMFraRK.js.map
+//# sourceMappingURL=index-BcJOeks0.js.map