orez 0.5.16 → 0.5.18

package/dist/zero-http/transport.js

@@ -1,18 +1,44 @@
+// http-pull transport: runs a stock @rocicorp/zero client over stateless HTTP
+// by intercepting its /sync/v51/connect WebSocket with a shim that translates
+// pull responses into v51 pokes.
+//
+// this file is the CANONICAL copy. takeout's on-zero and chat's
+// httpPullTransport.vendor.ts are downstream snapshots of it — evolve the
+// transport here and refresh them from here, never the other way. the wire
+// contract (lexicographic string cookies, gotQueriesPatch poke-part ordering,
+// FIFO push serialization, updateAuth, 401→Unauthorized frame, teardown
+// drain) is pinned by the sibling *.test.ts suite and documented in
+// plans/zero-http.md. do not "simplify" any of it without re-running those
+// tests against a stock zero client.
 const COOKIE_WIDTH = 20;
-const CONNECTED_QUERY_FLUSH_MS = 25;
-export function installZeroHttpTransport(opts) {
+const TRANSIENT_RECONNECT_BACKOFF_BASE_MS = 1_000;
+const TRANSIENT_RECONNECT_BACKOFF_MAX_MS = 30_000;
+export function installHttpPullTransport(opts) {
     const previousWebSocket = globalThis.WebSocket;
     const fetchImpl = opts.fetch ?? globalThis.fetch;
     if (!fetchImpl) {
-        throw new Error('installZeroHttpTransport requires a fetch implementation');
+        throw new Error('installHttpPullTransport requires a fetch implementation');
     }
     const state = {
+        appID: opts.appID ?? 'zero',
         origin: new URL(opts.origin),
         originString: trimTrailingSlash(new URL(opts.origin).toString()),
-        fetch: fetchImpl,
+        pushOriginString: trimTrailingSlash(new URL(opts.pushOrigin ?? opts.origin).toString()),
+        // the transport invokes this as `state.fetch(...)` — without binding,
+        // window.fetch sees `state` as its receiver and browsers throw
+        // "Illegal invocation" (node's fetch doesn't care, so tests can't catch it)
+        fetch: fetchImpl.bind(globalThis),
         nativeWebSocket: previousWebSocket,
         sockets: new Set(),
+        pullIntervalMs: opts.pullIntervalMs,
+        wake: opts.wake ?? false,
+        queryTransform: opts.queryTransform,
+        queryForward: opts.queryForward === true,
+        queryAware: opts.queryTransform !== undefined || opts.queryForward === true,
+        shardNum: opts.shardNum ?? 0,
         nextPokeID: 0,
+        socketGeneration: 0,
+        transientFailureCount: 0,
     };
     const Shim = class {
         static CONNECTING = 0;
@@ -34,6 +60,16 @@ export function installZeroHttpTransport(opts) {
         pull: async () => {
             await Promise.all([...state.sockets].map((socket) => socket.pull()));
         },
+        flush: async () => {
+            await Promise.resolve();
+            const generation = state.socketGeneration;
+            const sockets = [...state.sockets];
+            await Promise.all(sockets.map((socket) => socket.flush()));
+            if (state.socketGeneration !== generation ||
+                sockets.some((socket) => !state.sockets.has(socket))) {
+                throw new Error('transport changed during flush');
+            }
+        },
         get connections() {
             return state.sockets.size;
         },
@@ -44,6 +80,22 @@ export function installZeroHttpTransport(opts) {
         },
     };
 }
+// per-origin idempotent install for app usage (ProvideZero rotates zero
+// instances against the same server; installing per rotation would chain
+// shims unboundedly). installed transports live for the page lifetime.
+const transportsByOrigin = new Map();
+export function ensureHttpPullTransport(opts) {
+    const key = trimTrailingSlash(new URL(opts.origin).toString());
+    const existing = transportsByOrigin.get(key);
+    if (existing)
+        return existing;
+    const transport = installHttpPullTransport(opts);
+    transportsByOrigin.set(key, transport);
+    return transport;
+}
+export async function flushHttpPullTransports() {
+    await Promise.all([...transportsByOrigin.values()].map((transport) => transport.flush()));
+}
 class ZeroHttpSocket {
     state;
     CONNECTING = 0;
@@ -65,12 +117,32 @@ class ZeroHttpSocket {
     wsid;
     cookie;
     pendingGotQueriesPatch = [];
+    // every got-query hash acked to the client so far. a rowsPatch 'clear'
+    // resets the client's ENTIRE replicache space — rows AND got-query marks —
+    // so any clear-bearing poke must re-assert the full got set or queries the
+    // client already had marked complete silently regress to unknown forever
+    // (the transport never re-sends an ack it believes was delivered).
+    ackedGotHashes = new Set();
+    // query-aware extension state: the accumulated un-acked desired-query delta
+    // to ship, a client-side query-state version that bumps on each change, and
+    // the version/length of the delta the in-flight pull sent (to clear the
+    // acked prefix on the server's ack).
+    desiredQueryPatch = [];
+    queryVersion = 0;
+    sentQueryVersion;
+    sentQueryPatchLen = 0;
     pullInFlight;
     pullAfterCurrent = false;
     pushChain = Promise.resolve();
-    nextLocalCookieID = 0;
+    pushCompletion = Promise.resolve();
+    flushGeneration = 0;
+    pendingUpstream = new Set();
+    nextLocalCookieID;
     openTimer;
-    initialPullTimer;
+    pullTimer;
+    wakeSocket;
+    wakeConnecting = false;
+    wakeReconnectTimer;
     constructor(state, url, protocols) {
         this.state = state;
         this.connectURL = toHttpURL(url);
@@ -80,11 +152,20 @@ class ZeroHttpSocket {
         this.wsid = this.connectURL.searchParams.get('wsid') ?? `zero-http-${Date.now()}`;
         const baseCookie = this.connectURL.searchParams.get('baseCookie');
         this.cookie = baseCookie ? baseCookie : null;
+        // the local cookie ID is encoded into the suffix of any cookie we
+        // already advanced past (toLocalWebSocketCookie). reconnects rehydrate
+        // this.cookie from the URL baseCookie param replicache persisted, so we
+        // must resume the counter from its suffix — otherwise the first poke on
+        // the new socket re-emits an identical suffix and replicache trips
+        // "cookie did not change, but patch is not empty" and drops the patch.
+        const suffixMatch = this.cookie?.match(/#(\d+)$/);
+        this.nextLocalCookieID = suffixMatch ? Number(suffixMatch[1]) : 0;
         const decoded = decodeSecProtocol(protocols);
         this.authToken = decoded.authToken;
         this.queueDesiredQueries(decoded.initConnectionMessage?.[1]);
         this.state.sockets.add(this);
-        this.openTimer = setTimeout(() => this.open(), 0);
+        this.state.socketGeneration++;
+        this.openTimer = setTimeout(() => this.open(), reconnectDelayMs(this.state));
     }
     addEventListener(type, listener) {
         if (listener)
@@ -106,9 +187,12 @@ class ZeroHttpSocket {
         switch (message[0]) {
             case 'initConnection':
             case 'changeDesiredQueries':
-                this.receivedDesiredQueries(message[1]);
+                this.flushGeneration++;
+                this.queueDesiredQueries(message[1]);
+                this.requestPullAfterCurrent();
                 return;
             case 'updateAuth':
+                this.flushGeneration++;
                 this.authToken = message[1].auth;
                 return;
             case 'push':
@@ -117,9 +201,13 @@ class ZeroHttpSocket {
             case 'ping':
                 this.emitMessage(['pong', {}]);
                 return;
-            case 'pull':
-                this.run(this.answerMutationRecoveryPull(message[1]));
+            case 'pull': {
+                this.flushGeneration++;
+                const recoveryPull = this.answerMutationRecoveryPull(message[1]);
+                this.trackUpstream(recoveryPull);
+                this.run(recoveryPull);
                 return;
+            }
             case 'deleteClients':
             case 'ackMutationResponses':
                 return;
@@ -132,19 +220,23 @@ class ZeroHttpSocket {
             return;
         if (this.openTimer)
             clearTimeout(this.openTimer);
-        if (this.initialPullTimer)
-            clearTimeout(this.initialPullTimer);
+        if (this.pullTimer)
+            clearInterval(this.pullTimer);
+        this.closeWakeChannel();
         this.readyState = this.CLOSED;
-        this.state.sockets.delete(this);
+        if (this.state.sockets.delete(this))
+            this.state.socketGeneration++;
         this.emit('close', { code, reason, wasClean: code <= 1001 });
     }
     pull() {
-        if (this.readyState === this.CLOSED)
+        if (this.readyState !== this.OPEN)
             return Promise.resolve();
         if (this.pullInFlight)
             return this.pullInFlight;
-        this.pullInFlight = this.fetchPull(this.clientGroupID, this.cookie)
+        this.pullInFlight = this.fetchPull(this.clientGroupID, this.cookie, true)
             .then((response) => {
+            if (this.state.queryAware)
+                this.applyServerGotQueries(response);
             if (response.unchanged) {
                 this.emitGotQueriesPatch(response.cookie);
                 return;
@@ -164,49 +256,187 @@ class ZeroHttpSocket {
         });
         return this.pullInFlight;
     }
+    // settle every tracked upstream effect, then prove quiescence with a double
+    // pull round-trip. loops until a full pass completes with no new work
+    // (flushGeneration unchanged and nothing pending).
+    async flush() {
+        for (;;) {
+            const generation = this.flushGeneration;
+            await Promise.all([...this.pendingUpstream]);
+            await this.pushCompletion;
+            await this.pull();
+            await Promise.all([...this.pendingUpstream]);
+            await this.pushCompletion;
+            await this.pull();
+            await Promise.resolve();
+            if (this.flushGeneration === generation && this.pendingUpstream.size === 0) {
+                return;
+            }
+        }
+    }
     open() {
         if (this.readyState !== this.CONNECTING)
             return;
         this.readyState = this.OPEN;
         this.emit('open', {});
         this.emitMessage(['connected', { wsid: this.wsid, timestamp: Date.now() }]);
-        // zero may diff desired queries asynchronously after the connected frame.
-        // give that upstream init/change message first chance to drive the pull so
-        // the first snapshot can carry gotQueriesPatch for newly materialized views.
-        this.initialPullTimer = setTimeout(() => {
-            this.initialPullTimer = undefined;
-            this.run(this.pull());
-        }, CONNECTED_QUERY_FLUSH_MS);
+        setTimeout(() => this.run(this.pull()), 0);
+        if (this.state.pullIntervalMs) {
+            this.pullTimer = setInterval(() => {
+                this.run(this.pull());
+            }, this.state.pullIntervalMs);
+        }
+        if (this.state.wake)
+            void this.openWakeChannel();
+    }
+    // notification-only wake channel: a real WebSocket to <origin>/wake that
+    // carries no data. any frame means "pull now", so a wake triggers an
+    // immediate (coalesced) pull — push-shaped propagation without waiting on
+    // the poll interval. advisory only: if it drops we reconnect, and the
+    // interval poll remains the safety net that guarantees convergence.
+    async openWakeChannel() {
+        const Native = this.state.nativeWebSocket;
+        if (!Native ||
+            this.wakeSocket ||
+            this.wakeConnecting ||
+            this.readyState !== this.OPEN) {
+            return;
+        }
+        this.wakeConnecting = true;
+        const wsBase = this.state.originString.replace(/^http/, 'ws');
+        let wakeToken;
+        let socket;
+        try {
+            if (typeof this.state.wake === 'object') {
+                wakeToken = await this.state.wake.getToken();
+            }
+            if (this.readyState !== this.OPEN || this.wakeSocket)
+                return;
+            const url = `${wsBase}/wake?clientID=${encodeURIComponent(this.clientID)}` +
+                (wakeToken === undefined ? '' : `&wakeToken=${encodeURIComponent(wakeToken)}`);
+            socket = new Native(url);
+        }
+        catch {
+            this.scheduleWakeReconnect();
+            return;
+        }
+        finally {
+            this.wakeConnecting = false;
+        }
+        this.wakeSocket = socket;
+        const reconnect = () => {
+            if (this.wakeSocket !== socket)
+                return;
+            this.wakeSocket = undefined;
+            this.scheduleWakeReconnect();
+        };
+        // route through requestPullAfterCurrent, NOT pull() directly: a wake that
+        // lands while a pull is already in flight must set pullAfterCurrent so the
+        // in-flight pull re-runs and picks up the woken change. calling pull()
+        // directly would return the existing promise and silently drop the wake,
+        // leaving convergence to the safety poll (a burst-storm latency bug).
+        socket.onmessage = () => this.requestPullAfterCurrent();
+        socket.onclose = reconnect;
+        socket.onerror = reconnect;
+    }
+    scheduleWakeReconnect() {
+        if (this.readyState !== this.OPEN || this.wakeReconnectTimer)
+            return;
+        this.wakeReconnectTimer = setTimeout(() => {
+            this.wakeReconnectTimer = undefined;
+            void this.openWakeChannel();
+        }, 500);
+    }
+    closeWakeChannel() {
+        if (this.wakeReconnectTimer) {
+            clearTimeout(this.wakeReconnectTimer);
+            this.wakeReconnectTimer = undefined;
+        }
+        const socket = this.wakeSocket;
+        this.wakeSocket = undefined;
+        if (socket) {
+            try {
+                socket.close();
+            }
+            catch {
+                // best effort: an already-closing wake socket is harmless
+            }
+        }
     }
     queueDesiredQueries(body) {
         const desiredQueriesPatch = body
             ?.desiredQueriesPatch;
         if (!Array.isArray(desiredQueriesPatch))
             return;
-        this.pendingGotQueriesPatch.push(...gotQueriesPatch(desiredQueriesPatch));
-    }
-    receivedDesiredQueries(body) {
-        this.queueDesiredQueries(body);
-        if (this.initialPullTimer) {
-            clearTimeout(this.initialPullTimer);
-            this.initialPullTimer = undefined;
+        if (!this.state.queryAware) {
+            // baseline dialect: synthesize the got-query ack locally
+            this.pendingGotQueriesPatch.push(...gotQueriesPatch(desiredQueriesPatch));
+            return;
         }
-        this.requestPullAfterCurrent();
+        // query-aware: accumulate the desired-query delta to ship to the server. a
+        // put ships its inline ast, or a client-resolved ast (queryTransform), or
+        // name+args for the server to resolve (queryForward). the server owns the
+        // got-query ack.
+        const transform = this.state.queryTransform;
+        for (const op of desiredQueriesPatch) {
+            if (op.op === 'clear') {
+                this.desiredQueryPatch.push({ op: 'clear' });
+            }
+            else if (op.op === 'del') {
+                this.desiredQueryPatch.push({ op: 'del', hash: op.hash });
+            }
+            else if (op.op === 'put') {
+                const inline = op.ast;
+                const name = op.name ?? '';
+                const args = (op.args ??
+                    []);
+                if (this.state.queryForward) {
+                    this.desiredQueryPatch.push({ op: 'put', hash: op.hash, name, args });
+                }
+                else if (inline !== undefined) {
+                    this.desiredQueryPatch.push({ op: 'put', hash: op.hash, ast: inline });
+                }
+                else if (transform) {
+                    this.desiredQueryPatch.push({
+                        op: 'put',
+                        hash: op.hash,
+                        ast: transform(name, args),
+                    });
+                }
+            }
+        }
+        this.queryVersion++;
     }
     async push(body) {
         const response = (await this.postJSON('/push', body));
-        this.emitMessage(['pushResponse', response.pushResponse]);
+        // mutation RECOVERY pushes carry a PREVIOUS client's pending mutations,
+        // and the server response echoes that old clientID. zero-cache's pusher
+        // groups results by clientID and only delivers a client its OWN results
+        // (recovered mutations settle via lastMutationIDChanges in pokes); the
+        // raw response would trip zero's "received mutation for the wrong
+        // client" assert and kill the connection. mirror the same filtering.
+        this.emitMessage([
+            'pushResponse',
+            filterMutationResultsToClient('pushResponse' in response ? response.pushResponse : response, this.clientID),
+        ]);
         this.requestPullAfterCurrent();
     }
     enqueuePush(body) {
+        this.flushGeneration++;
         const nextPush = this.pushChain.then(async () => {
             if (this.readyState === this.CLOSED)
                 return;
             await this.push(body);
         });
+        this.pushCompletion = nextPush;
         this.pushChain = nextPush.catch(() => { });
+        this.trackUpstream(nextPush);
         this.run(nextPush);
     }
+    trackUpstream(promise) {
+        this.pendingUpstream.add(promise);
+        void promise.then(() => this.pendingUpstream.delete(promise), () => this.pendingUpstream.delete(promise));
+    }
     requestPullAfterCurrent() {
         if (this.pullInFlight) {
             this.pullAfterCurrent = true;
@@ -214,8 +444,23 @@ class ZeroHttpSocket {
         }
         this.run(this.pull());
     }
+    // in query-aware mode the got-query ack is authoritative from the server:
+    // take the server's gotQueries.patch as the got patch to emit (replacing
+    // local synthesis), and clear the acked prefix of the shipped desired delta
+    // once the server acks that version (the ack never leads its row effects —
+    // invariant 13 — so the client marks a query got only after its rows land).
+    applyServerGotQueries(response) {
+        const got = response.gotQueries;
+        this.pendingGotQueriesPatch = got ? got.patch : [];
+        if (got &&
+            this.sentQueryVersion !== undefined &&
+            got.version >= this.sentQueryVersion) {
+            this.desiredQueryPatch.splice(0, this.sentQueryPatchLen);
+            this.sentQueryVersion = undefined;
+        }
+    }
     async answerMutationRecoveryPull(body) {
-        const response = await this.fetchPull(body.clientGroupID, body.cookie);
+        const response = await this.fetchPull(body.clientGroupID, body.cookie, false);
         const cookie = toWebSocketCookie(response.cookie);
         this.emitMessage([
             'pull',
@@ -226,15 +471,33 @@ class ZeroHttpSocket {
             },
         ]);
     }
-    async fetchPull(clientGroupID, cookie) {
-        return (await this.postJSON('/pull', {
+    async fetchPull(clientGroupID, cookie, includeQueries) {
+        const body = {
             clientID: this.clientID,
             clientGroupID,
             cookie: toHttpCookie(cookie),
-        }));
+        };
+        // ship the un-acked desired-query delta with the pull; remember what we
+        // sent so the server ack can clear exactly that prefix. a recovery pull
+        // (includeQueries=false) never carries desires.
+        if (includeQueries && this.state.queryAware && this.desiredQueryPatch.length > 0) {
+            this.sentQueryVersion = this.queryVersion;
+            this.sentQueryPatchLen = this.desiredQueryPatch.length;
+            body.queries = { version: this.queryVersion, patch: [...this.desiredQueryPatch] };
+        }
+        else {
+            this.sentQueryVersion = undefined;
+        }
+        return (await this.postJSON('/pull', body));
     }
     async postJSON(path, body) {
-        const response = await this.state.fetch(`${this.state.originString}${path}`, {
+        const base = path === '/push' ? this.state.pushOriginString : this.state.originString;
+        const url = new URL(`${base}${path}`);
+        if (path === '/push') {
+            url.searchParams.set('schema', `${this.state.appID}_${this.state.shardNum}`);
+            url.searchParams.set('appID', this.state.appID);
+        }
+        const response = await this.state.fetch(url, {
             method: 'POST',
             headers: {
                 authorization: this.authToken ? `Bearer ${this.authToken}` : '',
@@ -245,6 +508,7 @@ class ZeroHttpSocket {
         if (!response.ok) {
             throw new ZeroHttpResponseError(path, response.status);
         }
+        resetTransientFailures(this.state);
         return response.json();
     }
     run(promise) {
@@ -266,17 +530,59 @@ class ZeroHttpSocket {
                 this.close(1000, error.message);
             return;
         }
+        if (isStaleClientCookieError(error)) {
+            // the client's cookie is AHEAD of the server watermark — the server
+            // lost or reset its change-tracking state (replica reset / restore).
+            // mirror zero-cache's InvalidConnectionRequestBaseCookie error frame so
+            // the stock client drops its local db and rebuilds from scratch instead
+            // of reconnect-looping on 409 forever.
+            this.emitMessage([
+                'error',
+                {
+                    kind: 'InvalidConnectionRequestBaseCookie',
+                    message: error.message,
+                    origin: 'server',
+                },
+            ]);
+            if (this.readyState !== this.CLOSED)
+                this.close(1000, error.message);
+            return;
+        }
+        recordTransientFailure(this.state);
         this.emit('error', { error });
         this.close(1011, errorMessage(error));
     }
     emitPoke(response) {
-        const nextCookie = toWebSocketCookie(response.cookie);
-        if (isStaleCookie(this.cookie, response.cookie)) {
+        const currentServer = toHttpCookie(this.cookie);
+        let nextCookie;
+        if (currentServer !== null && response.cookie < currentServer) {
+            // the server watermark is BEHIND the client: a real reset/restore. mirror
+            // the 409 stale path instead of poking the client backwards.
             throw new Error(`zero-http pull returned stale cookie ${response.cookie} for ${this.cookie}`);
         }
+        else if (currentServer !== null && response.cookie === currentServer) {
+            // same server watermark but a non-empty patch: a query-aware membership
+            // delta (a desired-query change recomputes rows without advancing the
+            // change log). bump a client-local cookie id so replicache sees a changed
+            // cookie — otherwise it trips "cookie did not change, but patch is not
+            // empty" and drops the patch.
+            nextCookie = toLocalWebSocketCookie(response.cookie, ++this.nextLocalCookieID);
+        }
+        else {
+            nextCookie = toWebSocketCookie(response.cookie);
+        }
         const pokeID = `zero-http-${++this.state.nextPokeID}`;
-        const gotQueries = this.pendingGotQueriesPatch;
+        let gotQueries = dedupeGotQueriesPatch(this.pendingGotQueriesPatch);
         this.pendingGotQueriesPatch = [];
+        const rowsCleared = Array.isArray(response.rowsPatch) &&
+            response.rowsPatch.some((op) => op?.op === 'clear');
+        if (rowsCleared && this.ackedGotHashes.size > 0) {
+            gotQueries = dedupeGotQueriesPatch([
+                ...[...this.ackedGotHashes].map((hash) => ({ op: 'put', hash })),
+                ...gotQueries,
+            ]);
+        }
+        this.recordAckedGotQueries(gotQueries);
         this.emitMessage([
             'pokeStart',
             {
@@ -317,8 +623,9 @@ class ZeroHttpSocket {
             return;
         const nextCookie = toLocalWebSocketCookie(serverCookie, ++this.nextLocalCookieID);
         const pokeID = `zero-http-${++this.state.nextPokeID}`;
-        const gotQueries = this.pendingGotQueriesPatch;
+        const gotQueries = dedupeGotQueriesPatch(this.pendingGotQueriesPatch);
         this.pendingGotQueriesPatch = [];
+        this.recordAckedGotQueries(gotQueries);
         this.emitMessage([
             'pokeStart',
             {
@@ -341,6 +648,16 @@ class ZeroHttpSocket {
         this.emitMessage(['pokeEnd', { pokeID, cookie: nextCookie }]);
         this.cookie = nextCookie;
     }
+    recordAckedGotQueries(patch) {
+        for (const op of patch) {
+            if (op.op === 'clear')
+                this.ackedGotHashes.clear();
+            else if (op.op === 'put')
+                this.ackedGotHashes.add(op.hash);
+            else
+                this.ackedGotHashes.delete(op.hash);
+        }
+    }
     emitMessage(message) {
         if (this.readyState !== this.OPEN)
             return;
@@ -404,6 +721,28 @@ function gotQueriesPatch(patch) {
     }
     return got;
 }
+// the same query hash can be acked twice into one poke: the sec-protocol
+// initConnection queues its got-ack in the constructor, and a racing
+// changeDesiredQueries send() queues it again before the in-flight pull's
+// poke consumes the pending patch. a duplicate put for one hash inside a
+// single gotQueriesPatch stalls the zero client's complete tracking, so
+// collapse to the last op per hash (a clear resets everything before it).
+function dedupeGotQueriesPatch(patch) {
+    let clear = false;
+    const lastOpByHash = new Map();
+    for (const op of patch) {
+        if (op.op === 'clear') {
+            clear = true;
+            lastOpByHash.clear();
+            continue;
+        }
+        lastOpByHash.delete(op.hash);
+        lastOpByHash.set(op.hash, op);
+    }
+    const deduped = clear ? [{ op: 'clear' }] : [];
+    deduped.push(...lastOpByHash.values());
+    return deduped;
+}
 function toHttpCookie(cookie) {
     if (cookie === null || cookie === '')
         return null;
@@ -419,10 +758,6 @@ function toWebSocketCookie(cookie) {
 function toLocalWebSocketCookie(cookie, localID) {
     return `${String(cookie).padStart(COOKIE_WIDTH, '0')}#${String(localID).padStart(6, '0')}`;
 }
-function isStaleCookie(current, next) {
-    const currentNumber = toHttpCookie(current);
-    return currentNumber !== null && next <= currentNumber;
-}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -439,4 +774,36 @@ function isAuthHTTPError(error) {
     return (error instanceof ZeroHttpResponseError &&
         (error.status === 401 || error.status === 403));
 }
+// keep only this client's own mutation results — zero-cache's pusher does the
+// same per-client fan-out (results for clients without a live connection are
+// dropped; their LMID advance arrives via the next pull's
+// lastMutationIDChanges, which is how recovered mutations settle).
+function filterMutationResultsToClient(pushResponse, clientID) {
+    if (!pushResponse || typeof pushResponse !== 'object')
+        return pushResponse;
+    const mutations = pushResponse.mutations;
+    if (!Array.isArray(mutations))
+        return pushResponse;
+    return {
+        ...pushResponse,
+        mutations: mutations.filter((m) => m?.id?.clientID === clientID),
+    };
+}
+function isStaleClientCookieError(error) {
+    return (error instanceof ZeroHttpResponseError &&
+        error.path === '/pull' &&
+        error.status === 409);
+}
+function reconnectDelayMs(state) {
+    if (state.transientFailureCount === 0)
+        return 0;
+    return Math.min(TRANSIENT_RECONNECT_BACKOFF_BASE_MS * 2 ** (state.transientFailureCount - 1), TRANSIENT_RECONNECT_BACKOFF_MAX_MS);
+}
+function recordTransientFailure(state) {
+    const maxExponent = Math.log2(TRANSIENT_RECONNECT_BACKOFF_MAX_MS / TRANSIENT_RECONNECT_BACKOFF_BASE_MS);
+    state.transientFailureCount = Math.min(state.transientFailureCount + 1, Math.ceil(maxExponent) + 1);
+}
+function resetTransientFailures(state) {
+    state.transientFailureCount = 0;
+}
 //# sourceMappingURL=transport.js.map