shennian 0.3.85 → 0.3.86

package/dist/src/session/history-subscriptions.js

@@ -1 +1,470 @@
-import{SESSION_HISTORY_LIMITS as l}from"@shennian/wire";import{getCanonicalSessionStore as M,listSessionRecords as _}from"./store.js";import{recordPersonalSyncLocalMetric as d,setPersonalSyncLocalSubscriptions as I}from"../personal-sync/metrics.js";import{assertPersonalSyncIdentity as p,getPersonalSyncIdentity as u}from"../personal-sync/epoch.js";const y=100,b=l.maxDeltaMutations,g=l.maxMutationBytes-4096,m=l.maxReplicaPageBytes-16384;class O{client;store;hasLocalSession;subscriptions=new Map;replicaStreams=new Map;unsubscribeStore;constructor(s,e=M(),i=t=>_().some(n=>n.sessionId===t)){this.client=s,this.store=e,this.hasLocalSession=i,this.unsubscribeStore=e.subscribe(t=>this.handleMutation(t))}handleOpen(s){const e=s.params;if(p(e),h(e.sessionId,e.subscriptionId),!this.hasLocalSession(e.sessionId)&&!this.store.getManifest(e.sessionId))throw new Error("history_unavailable");if(this.subscriptions.has(e.subscriptionId))throw new Error("subscription already exists");if([...this.subscriptions.values()].filter(n=>n.sessionId===e.sessionId).length>=l.maxSubscriptionsPerSession){this.client.sendRes({type:"res",id:s.id,ok:!1,error:"subscription_limit_exceeded",rejection:{code:"subscription_limit_exceeded",retryable:!0,requiredAction:"retry"}});return}const t={sessionId:e.sessionId,subscriptionId:e.subscriptionId,snapshotRevision:0,lastSentRevision:0,active:!1,buffered:[],pending:[],pendingBytes:0,flushTimer:null,lastQueuedRevision:0};this.subscriptions.set(e.subscriptionId,t),this.updateSubscriptionMetric();try{const n=this.store.readPage(e.sessionId,{limit:R(e.limit,l.defaultSnapshotMessages),...e.beforeSequence===void 0?{}:{beforeSequence:e.beforeSequence}});t.snapshotRevision=n.bodyRevision,t.lastSentRevision=n.bodyRevision,t.lastQueuedRevision=n.bodyRevision,this.client.sendRes({type:"res",id:s.id,ok:!0,payload:{...u(this.store.daemonInstallationId),sessionId:e.sessionId,subscriptionId:e.subscriptionId,storageMode:"machine_local",snapshotRevision:n.bodyRevision,firstAvailableSeq:n.firstAvailableSeq,lastAvailableSeq:n.lastAvailableSeq,hasOlder:n.hasOlder,messages:n.entries}}),d("historySnapshots"),d("historyBytesServed",Buffer.byteLength(JSON.stringify(n.entries),"utf8")),t.active=!0;for(const o of t.buffered)this.queueMutation(t,o);t.buffered=[]}catch(n){throw this.subscriptions.delete(e.subscriptionId),this.updateSubscriptionMetric(),n}}handleSync(s){const e=s.params;if(p(e),h(e.sessionId,e.syncId),!Number.isSafeInteger(e.afterRevision)||e.afterRevision<0)throw new Error("invalid history sync revision");if(!this.hasLocalSession(e.sessionId)&&!this.store.getManifest(e.sessionId))throw new Error("history_unavailable");const i=this.store.getManifest(e.sessionId)?.bodyRevision??0;if(e.afterRevision>i)throw new Error("revision_gap");const t=T(e.limit),n=this.store.readDeltas(e.sessionId,e.afterRevision,t),o=[];let r=0;for(const B of n){const S={...B,subscriptionId:e.syncId},f=Buffer.byteLength(JSON.stringify(S),"utf8")+1;if(o.length>0&&r+f>m)break;if(f>m){this.client.sendRes({type:"res",id:s.id,ok:!1,error:"response_too_large"});return}o.push(S),r+=f}const c=o.at(-1)?.revision??e.afterRevision;this.client.sendRes({type:"res",id:s.id,ok:!0,payload:{...u(this.store.daemonInstallationId),sessionId:e.sessionId,syncId:e.syncId,fromRevision:e.afterRevision,toRevision:c,targetRevision:i,hasMore:c<i,mutations:o}}),d("historyDeltas"),d("historyBytesServed",r)}handleReplicaSubscribe(s){const e=s.params;if(p(e),v(e.appInstallationId,e.streamId,e.generation),!this.replicaStreams.has(e.streamId)&&this.replicaStreams.size>=l.maxReplicaStreamsPerDaemon){this.client.sendRes({type:"res",id:s.id,ok:!1,error:"subscription_limit_exceeded",rejection:{code:"subscription_limit_exceeded",retryable:!0,requiredAction:"retry"}});return}const i=this.replicaStreams.get(e.streamId);if(i&&e.generation<i.generation)throw new Error("invalid body replica generation");i&&this.flushReplicaStream(i);const t={appInstallationId:e.appInstallationId,streamId:e.streamId,generation:e.generation,active:!1,buffered:[],highWaterBySession:new Map,lastSentBySession:new Map,lastQueuedBySession:new Map,pendingBySession:new Map,pendingCount:0,pendingBytes:0,flushTimer:null};this.replicaStreams.set(e.streamId,t),this.updateSubscriptionMetric();const n=this.store.listSessionIds().map(o=>{const r=this.store.getManifest(o)?.bodyRevision??0;return t.highWaterBySession.set(o,r),t.lastSentBySession.set(o,r),t.lastQueuedBySession.set(o,r),{sessionId:o,bodyRevision:r}});this.client.sendRes({type:"res",id:s.id,ok:!0,payload:{...u(this.store.daemonInstallationId),appInstallationId:e.appInstallationId,streamId:e.streamId,generation:e.generation,highWatermarks:n}}),t.active=!0;for(const o of t.buffered)this.queueReplicaMutation(t,o);t.buffered=[]}handleReplicaUnsubscribe(s){const e=s.params;p(e),v(e.appInstallationId,e.streamId,e.generation);const i=this.replicaStreams.get(e.streamId);i&&i.generation===e.generation&&(this.flushReplicaStream(i),this.replicaStreams.delete(e.streamId),this.updateSubscriptionMetric()),this.client.sendRes({type:"res",id:s.id,ok:!0,payload:{...u(this.store.daemonInstallationId),appInstallationId:e.appInstallationId,streamId:e.streamId,generation:e.generation,closed:!0}})}handlePage(s){const e=s.params;p(e);const i=this.requireSubscription(e.sessionId,e.subscriptionId);let t;try{t=this.store.readPageAtRevision(e.sessionId,{beforeSequence:e.beforeSequence,limit:R(e.limit,l.defaultPageMessages),revision:i.snapshotRevision})}catch{throw new Error("snapshot_compacted")}this.client.sendRes({type:"res",id:s.id,ok:!0,payload:{...u(this.store.daemonInstallationId),sessionId:e.sessionId,subscriptionId:e.subscriptionId,snapshotRevision:i.snapshotRevision,firstAvailableSeq:t.firstAvailableSeq,hasOlder:t.hasOlder,messages:t.entries}}),d("historyPages"),d("historyBytesServed",Buffer.byteLength(JSON.stringify(t.entries),"utf8"))}handleClose(s){const e=s.params;p(e),h(e.sessionId,e.subscriptionId);const i=this.subscriptions.get(e.subscriptionId);i?.sessionId===e.sessionId&&(this.flushSubscription(i),this.subscriptions.delete(e.subscriptionId),this.updateSubscriptionMetric()),this.client.sendRes({type:"res",id:s.id,ok:!0,payload:{...u(this.store.daemonInstallationId),sessionId:e.sessionId,subscriptionId:e.subscriptionId,closed:!0}})}closeAll(){for(const s of this.subscriptions.values())this.flushSubscription(s);for(const s of this.replicaStreams.values())this.flushReplicaStream(s);this.subscriptions.clear(),this.replicaStreams.clear(),I(0),this.unsubscribeStore()}closeSession(s){for(const[e,i]of this.subscriptions.entries())i.sessionId===s&&(this.flushSubscription(i),this.subscriptions.delete(e));this.updateSubscriptionMetric()}handleMutation(s){for(const e of this.subscriptions.values())e.sessionId===s.sessionId&&(e.active?this.queueMutation(e,s):e.buffered.push(s));for(const e of this.replicaStreams.values())e.active?this.queueReplicaMutation(e,s):e.buffered.push(s)}queueReplicaMutation(s,e){const i=s.lastQueuedBySession.get(e.sessionId)??0;if(e.revision<=i)return;const t=Buffer.byteLength(JSON.stringify({...e,subscriptionId:s.streamId}),"utf8")+1;s.pendingCount>0&&s.pendingBytes+t>g&&this.flushReplicaStream(s);const n=s.pendingBySession.get(e.sessionId)??[];if(n.push(e),s.pendingBySession.set(e.sessionId,n),s.pendingCount++,s.pendingBytes+=t,s.lastQueuedBySession.set(e.sessionId,e.revision),s.pendingCount>=b){this.flushReplicaStream(s);return}s.flushTimer||(s.flushTimer=setTimeout(()=>this.flushReplicaStream(s),y))}flushReplicaStream(s){if(s.flushTimer&&(clearTimeout(s.flushTimer),s.flushTimer=null),s.pendingCount===0)return;const e=[...s.pendingBySession.entries()].flatMap(([i,t])=>{const n=s.lastSentBySession.get(i)??0,o=t.filter(c=>c.revision>n);if(o.length===0)return[];const r=o[o.length-1].revision;return s.lastSentBySession.set(i,r),[{sessionId:i,fromRevision:n,toRevision:r,mutations:o.map(c=>({...c,subscriptionId:s.streamId}))}]});s.pendingBySession.clear(),s.pendingCount=0,s.pendingBytes=0,e.length!==0&&(this.client.sendEvent({type:"event",event:"session.body.replica.delta",payload:{...u(this.store.daemonInstallationId),appInstallationId:s.appInstallationId,streamId:s.streamId,generation:s.generation,batches:e}}),d("historyDeltas"),d("historyBytesServed",Buffer.byteLength(JSON.stringify(e),"utf8")))}queueMutation(s,e){if(e.revision<=s.lastQueuedRevision)return;const i=Buffer.byteLength(JSON.stringify({...e,subscriptionId:s.subscriptionId}),"utf8")+1;if(s.pending.length>0&&s.pendingBytes+i>g&&this.flushSubscription(s),s.pending.push(e),s.pendingBytes+=i,s.lastQueuedRevision=e.revision,s.pending.length>=b){this.flushSubscription(s);return}s.flushTimer||(s.flushTimer=setTimeout(()=>this.flushSubscription(s),y))}flushSubscription(s){if(s.flushTimer&&(clearTimeout(s.flushTimer),s.flushTimer=null),s.pending.length===0)return;const e=s.pending.filter(t=>t.revision>s.lastSentRevision);if(s.pending=[],s.pendingBytes=0,e.length===0)return;const i=e[e.length-1].revision;this.client.sendEvent({type:"event",event:"session.body.delta",payload:{...u(this.store.daemonInstallationId),sessionId:s.sessionId,subscriptionId:s.subscriptionId,fromRevision:s.lastSentRevision,toRevision:i,mutations:e.map(t=>({...t,subscriptionId:s.subscriptionId}))}}),d("historyDeltas"),d("historyBytesServed",Buffer.byteLength(JSON.stringify(e),"utf8")),s.lastSentRevision=i}requireSubscription(s,e){h(s,e);const i=this.subscriptions.get(e);if(!i||i.sessionId!==s)throw new Error("subscription_not_found");return i}updateSubscriptionMetric(){I(this.subscriptions.size+this.replicaStreams.size)}}function h(a,s){if(typeof a!="string"||!a||typeof s!="string"||!s)throw new Error("invalid history subscription identity")}function v(a,s,e){if(typeof a!="string"||!a||typeof s!="string"||!s||!Number.isSafeInteger(e)||e<1)throw new Error("invalid body replica stream identity")}function R(a,s){const e=a??s;if(!Number.isSafeInteger(e)||e<1||e>l.maxPageMessages)throw new Error("invalid history limit");return e}function T(a){const s=a??l.maxDeltaMutations;if(!Number.isSafeInteger(s)||s<1||s>l.maxDeltaMutations)throw new Error("invalid history sync limit");return s}export{b as PERSONAL_HISTORY_DELTA_BATCH_MAX_MUTATIONS,y as PERSONAL_HISTORY_DELTA_BATCH_WINDOW_MS,O as PersonalHistorySubscriptions};
+// @arch docs/architecture/data-sync.md#8-打开会话快照与实时订阅必须无缝衔接
+// @test src/__tests__/history-subscriptions.test.ts
+import { SESSION_HISTORY_LIMITS, } from '@shennian/wire';
+import { getCanonicalSessionStore, listSessionRecords } from './store.js';
+import { recordPersonalSyncLocalMetric, setPersonalSyncLocalSubscriptions, } from '../personal-sync/metrics.js';
+import { assertPersonalSyncIdentity, getPersonalSyncIdentity } from '../personal-sync/epoch.js';
+export const PERSONAL_HISTORY_DELTA_BATCH_WINDOW_MS = 100;
+export const PERSONAL_HISTORY_DELTA_BATCH_MAX_MUTATIONS = SESSION_HISTORY_LIMITS.maxDeltaMutations;
+const PERSONAL_HISTORY_DELTA_BATCH_MAX_BYTES = SESSION_HISTORY_LIMITS.maxMutationBytes - 4_096;
+const PERSONAL_HISTORY_REPLICA_PAGE_MAX_BYTES = SESSION_HISTORY_LIMITS.maxReplicaPageBytes - 16_384;
+export class PersonalHistorySubscriptions {
+    client;
+    store;
+    hasLocalSession;
+    subscriptions = new Map();
+    replicaStreams = new Map();
+    unsubscribeStore;
+    constructor(client, store = getCanonicalSessionStore(), hasLocalSession = (sessionId) => listSessionRecords().some((record) => record.sessionId === sessionId)) {
+        this.client = client;
+        this.store = store;
+        this.hasLocalSession = hasLocalSession;
+        this.unsubscribeStore = store.subscribe((mutation) => this.handleMutation(mutation));
+    }
+    handleOpen(req) {
+        const params = req.params;
+        assertPersonalSyncIdentity(params);
+        validateIdentity(params.sessionId, params.subscriptionId);
+        // A missing canonical manifest is valid only for a locally known, newly
+        // created empty session. Server metadata from an earlier hard-cut epoch
+        // must never be projected as a successful empty transcript.
+        if (!this.hasLocalSession(params.sessionId) && !this.store.getManifest(params.sessionId)) {
+            throw new Error('history_unavailable');
+        }
+        if (this.subscriptions.has(params.subscriptionId))
+            throw new Error('subscription already exists');
+        const sameSessionCount = [...this.subscriptions.values()]
+            .filter((item) => item.sessionId === params.sessionId).length;
+        if (sameSessionCount >= SESSION_HISTORY_LIMITS.maxSubscriptionsPerSession) {
+            this.client.sendRes({
+                type: 'res',
+                id: req.id,
+                ok: false,
+                error: 'subscription_limit_exceeded',
+                rejection: {
+                    code: 'subscription_limit_exceeded',
+                    retryable: true,
+                    requiredAction: 'retry',
+                },
+            });
+            return;
+        }
+        const subscription = {
+            sessionId: params.sessionId,
+            subscriptionId: params.subscriptionId,
+            snapshotRevision: 0,
+            lastSentRevision: 0,
+            active: false,
+            buffered: [],
+            pending: [],
+            pendingBytes: 0,
+            flushTimer: null,
+            lastQueuedRevision: 0,
+        };
+        this.subscriptions.set(params.subscriptionId, subscription);
+        this.updateSubscriptionMetric();
+        try {
+            const page = this.store.readPage(params.sessionId, {
+                limit: normalizeLimit(params.limit, SESSION_HISTORY_LIMITS.defaultSnapshotMessages),
+                ...(params.beforeSequence === undefined ? {} : { beforeSequence: params.beforeSequence }),
+            });
+            subscription.snapshotRevision = page.bodyRevision;
+            subscription.lastSentRevision = page.bodyRevision;
+            subscription.lastQueuedRevision = page.bodyRevision;
+            this.client.sendRes({
+                type: 'res', id: req.id, ok: true,
+                payload: {
+                    ...getPersonalSyncIdentity(this.store.daemonInstallationId),
+                    sessionId: params.sessionId,
+                    subscriptionId: params.subscriptionId,
+                    storageMode: 'machine_local',
+                    snapshotRevision: page.bodyRevision,
+                    firstAvailableSeq: page.firstAvailableSeq,
+                    lastAvailableSeq: page.lastAvailableSeq,
+                    hasOlder: page.hasOlder,
+                    messages: page.entries,
+                },
+            });
+            recordPersonalSyncLocalMetric('historySnapshots');
+            recordPersonalSyncLocalMetric('historyBytesServed', Buffer.byteLength(JSON.stringify(page.entries), 'utf8'));
+            subscription.active = true;
+            for (const mutation of subscription.buffered)
+                this.queueMutation(subscription, mutation);
+            subscription.buffered = [];
+        }
+        catch (error) {
+            this.subscriptions.delete(params.subscriptionId);
+            this.updateSubscriptionMetric();
+            throw error;
+        }
+    }
+    handleSync(req) {
+        const params = req.params;
+        assertPersonalSyncIdentity(params);
+        validateIdentity(params.sessionId, params.syncId);
+        if (!Number.isSafeInteger(params.afterRevision) || params.afterRevision < 0) {
+            throw new Error('invalid history sync revision');
+        }
+        if (!this.hasLocalSession(params.sessionId) && !this.store.getManifest(params.sessionId)) {
+            throw new Error('history_unavailable');
+        }
+        const targetRevision = this.store.getManifest(params.sessionId)?.bodyRevision ?? 0;
+        if (params.afterRevision > targetRevision)
+            throw new Error('revision_gap');
+        const limit = normalizeSyncLimit(params.limit);
+        const available = this.store.readDeltas(params.sessionId, params.afterRevision, limit);
+        const mutations = [];
+        let bytes = 0;
+        for (const mutation of available) {
+            const projected = { ...mutation, subscriptionId: params.syncId };
+            const mutationBytes = Buffer.byteLength(JSON.stringify(projected), 'utf8') + 1;
+            if (mutations.length > 0 && bytes + mutationBytes > PERSONAL_HISTORY_REPLICA_PAGE_MAX_BYTES)
+                break;
+            if (mutationBytes > PERSONAL_HISTORY_REPLICA_PAGE_MAX_BYTES) {
+                this.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'response_too_large' });
+                return;
+            }
+            mutations.push(projected);
+            bytes += mutationBytes;
+        }
+        const toRevision = mutations.at(-1)?.revision ?? params.afterRevision;
+        this.client.sendRes({
+            type: 'res', id: req.id, ok: true,
+            payload: {
+                ...getPersonalSyncIdentity(this.store.daemonInstallationId),
+                sessionId: params.sessionId,
+                syncId: params.syncId,
+                fromRevision: params.afterRevision,
+                toRevision,
+                targetRevision,
+                hasMore: toRevision < targetRevision,
+                mutations,
+            },
+        });
+        recordPersonalSyncLocalMetric('historyDeltas');
+        recordPersonalSyncLocalMetric('historyBytesServed', bytes);
+    }
+    handleReplicaSubscribe(req) {
+        const params = req.params;
+        assertPersonalSyncIdentity(params);
+        validateStreamIdentity(params.appInstallationId, params.streamId, params.generation);
+        if (!this.replicaStreams.has(params.streamId)
+            && this.replicaStreams.size >= SESSION_HISTORY_LIMITS.maxReplicaStreamsPerDaemon) {
+            this.client.sendRes({
+                type: 'res', id: req.id, ok: false, error: 'subscription_limit_exceeded',
+                rejection: {
+                    code: 'subscription_limit_exceeded', retryable: true, requiredAction: 'retry',
+                },
+            });
+            return;
+        }
+        const previous = this.replicaStreams.get(params.streamId);
+        if (previous && params.generation < previous.generation) {
+            throw new Error('invalid body replica generation');
+        }
+        if (previous)
+            this.flushReplicaStream(previous);
+        const stream = {
+            appInstallationId: params.appInstallationId,
+            streamId: params.streamId,
+            generation: params.generation,
+            active: false,
+            buffered: [],
+            highWaterBySession: new Map(),
+            lastSentBySession: new Map(),
+            lastQueuedBySession: new Map(),
+            pendingBySession: new Map(),
+            pendingCount: 0,
+            pendingBytes: 0,
+            flushTimer: null,
+        };
+        // Register before capturing high-water marks. Commits racing this scan are
+        // buffered, then filtered against the captured revision after the response.
+        this.replicaStreams.set(params.streamId, stream);
+        this.updateSubscriptionMetric();
+        const highWatermarks = this.store.listSessionIds().map((sessionId) => {
+            const bodyRevision = this.store.getManifest(sessionId)?.bodyRevision ?? 0;
+            stream.highWaterBySession.set(sessionId, bodyRevision);
+            stream.lastSentBySession.set(sessionId, bodyRevision);
+            stream.lastQueuedBySession.set(sessionId, bodyRevision);
+            return { sessionId, bodyRevision };
+        });
+        this.client.sendRes({
+            type: 'res', id: req.id, ok: true,
+            payload: {
+                ...getPersonalSyncIdentity(this.store.daemonInstallationId),
+                appInstallationId: params.appInstallationId,
+                streamId: params.streamId,
+                generation: params.generation,
+                highWatermarks,
+            },
+        });
+        stream.active = true;
+        for (const mutation of stream.buffered)
+            this.queueReplicaMutation(stream, mutation);
+        stream.buffered = [];
+    }
+    handleReplicaUnsubscribe(req) {
+        const params = req.params;
+        assertPersonalSyncIdentity(params);
+        validateStreamIdentity(params.appInstallationId, params.streamId, params.generation);
+        const stream = this.replicaStreams.get(params.streamId);
+        if (stream && stream.generation === params.generation) {
+            this.flushReplicaStream(stream);
+            this.replicaStreams.delete(params.streamId);
+            this.updateSubscriptionMetric();
+        }
+        this.client.sendRes({
+            type: 'res', id: req.id, ok: true,
+            payload: {
+                ...getPersonalSyncIdentity(this.store.daemonInstallationId),
+                appInstallationId: params.appInstallationId,
+                streamId: params.streamId,
+                generation: params.generation,
+                closed: true,
+            },
+        });
+    }
+    handlePage(req) {
+        const params = req.params;
+        assertPersonalSyncIdentity(params);
+        const subscription = this.requireSubscription(params.sessionId, params.subscriptionId);
+        let page;
+        try {
+            page = this.store.readPageAtRevision(params.sessionId, {
+                beforeSequence: params.beforeSequence,
+                limit: normalizeLimit(params.limit, SESSION_HISTORY_LIMITS.defaultPageMessages),
+                revision: subscription.snapshotRevision,
+            });
+        }
+        catch {
+            throw new Error('snapshot_compacted');
+        }
+        this.client.sendRes({
+            type: 'res', id: req.id, ok: true,
+            payload: {
+                ...getPersonalSyncIdentity(this.store.daemonInstallationId),
+                sessionId: params.sessionId,
+                subscriptionId: params.subscriptionId,
+                snapshotRevision: subscription.snapshotRevision,
+                firstAvailableSeq: page.firstAvailableSeq,
+                hasOlder: page.hasOlder,
+                messages: page.entries,
+            },
+        });
+        recordPersonalSyncLocalMetric('historyPages');
+        recordPersonalSyncLocalMetric('historyBytesServed', Buffer.byteLength(JSON.stringify(page.entries), 'utf8'));
+    }
+    handleClose(req) {
+        const params = req.params;
+        assertPersonalSyncIdentity(params);
+        validateIdentity(params.sessionId, params.subscriptionId);
+        const subscription = this.subscriptions.get(params.subscriptionId);
+        if (subscription?.sessionId === params.sessionId) {
+            this.flushSubscription(subscription);
+            this.subscriptions.delete(params.subscriptionId);
+            this.updateSubscriptionMetric();
+        }
+        this.client.sendRes({
+            type: 'res', id: req.id, ok: true,
+            payload: {
+                ...getPersonalSyncIdentity(this.store.daemonInstallationId),
+                sessionId: params.sessionId, subscriptionId: params.subscriptionId, closed: true,
+            },
+        });
+    }
+    closeAll() {
+        for (const subscription of this.subscriptions.values())
+            this.flushSubscription(subscription);
+        for (const stream of this.replicaStreams.values())
+            this.flushReplicaStream(stream);
+        this.subscriptions.clear();
+        this.replicaStreams.clear();
+        setPersonalSyncLocalSubscriptions(0);
+        this.unsubscribeStore();
+    }
+    closeSession(sessionId) {
+        for (const [subscriptionId, subscription] of this.subscriptions.entries()) {
+            if (subscription.sessionId !== sessionId)
+                continue;
+            this.flushSubscription(subscription);
+            this.subscriptions.delete(subscriptionId);
+        }
+        this.updateSubscriptionMetric();
+    }
+    handleMutation(mutation) {
+        for (const subscription of this.subscriptions.values()) {
+            if (subscription.sessionId !== mutation.sessionId)
+                continue;
+            if (!subscription.active)
+                subscription.buffered.push(mutation);
+            else
+                this.queueMutation(subscription, mutation);
+        }
+        for (const stream of this.replicaStreams.values()) {
+            if (!stream.active)
+                stream.buffered.push(mutation);
+            else
+                this.queueReplicaMutation(stream, mutation);
+        }
+    }
+    queueReplicaMutation(stream, mutation) {
+        const lastQueued = stream.lastQueuedBySession.get(mutation.sessionId) ?? 0;
+        if (mutation.revision <= lastQueued)
+            return;
+        const mutationBytes = Buffer.byteLength(JSON.stringify({
+            ...mutation,
+            subscriptionId: stream.streamId,
+        }), 'utf8') + 1;
+        if (stream.pendingCount > 0
+            && stream.pendingBytes + mutationBytes > PERSONAL_HISTORY_DELTA_BATCH_MAX_BYTES) {
+            this.flushReplicaStream(stream);
+        }
+        const pending = stream.pendingBySession.get(mutation.sessionId) ?? [];
+        pending.push(mutation);
+        stream.pendingBySession.set(mutation.sessionId, pending);
+        stream.pendingCount++;
+        stream.pendingBytes += mutationBytes;
+        stream.lastQueuedBySession.set(mutation.sessionId, mutation.revision);
+        if (stream.pendingCount >= PERSONAL_HISTORY_DELTA_BATCH_MAX_MUTATIONS) {
+            this.flushReplicaStream(stream);
+            return;
+        }
+        if (stream.flushTimer)
+            return;
+        stream.flushTimer = setTimeout(() => this.flushReplicaStream(stream), PERSONAL_HISTORY_DELTA_BATCH_WINDOW_MS);
+    }
+    flushReplicaStream(stream) {
+        if (stream.flushTimer) {
+            clearTimeout(stream.flushTimer);
+            stream.flushTimer = null;
+        }
+        if (stream.pendingCount === 0)
+            return;
+        const batches = [...stream.pendingBySession.entries()].flatMap(([sessionId, pending]) => {
+            const lastSent = stream.lastSentBySession.get(sessionId) ?? 0;
+            const mutations = pending.filter((mutation) => mutation.revision > lastSent);
+            if (mutations.length === 0)
+                return [];
+            const toRevision = mutations[mutations.length - 1].revision;
+            stream.lastSentBySession.set(sessionId, toRevision);
+            return [{
+                    sessionId,
+                    fromRevision: lastSent,
+                    toRevision,
+                    mutations: mutations.map((mutation) => ({
+                        ...mutation,
+                        subscriptionId: stream.streamId,
+                    })),
+                }];
+        });
+        stream.pendingBySession.clear();
+        stream.pendingCount = 0;
+        stream.pendingBytes = 0;
+        if (batches.length === 0)
+            return;
+        this.client.sendEvent({
+            type: 'event',
+            event: 'session.body.replica.delta',
+            payload: {
+                ...getPersonalSyncIdentity(this.store.daemonInstallationId),
+                appInstallationId: stream.appInstallationId,
+                streamId: stream.streamId,
+                generation: stream.generation,
+                batches,
+            },
+        });
+        recordPersonalSyncLocalMetric('historyDeltas');
+        recordPersonalSyncLocalMetric('historyBytesServed', Buffer.byteLength(JSON.stringify(batches), 'utf8'));
+    }
+    queueMutation(subscription, mutation) {
+        if (mutation.revision <= subscription.lastQueuedRevision)
+            return;
+        const mutationBytes = Buffer.byteLength(JSON.stringify({
+            ...mutation,
+            subscriptionId: subscription.subscriptionId,
+        }), 'utf8') + 1;
+        if (subscription.pending.length > 0 &&
+            subscription.pendingBytes + mutationBytes > PERSONAL_HISTORY_DELTA_BATCH_MAX_BYTES)
+            this.flushSubscription(subscription);
+        subscription.pending.push(mutation);
+        subscription.pendingBytes += mutationBytes;
+        subscription.lastQueuedRevision = mutation.revision;
+        if (subscription.pending.length >= PERSONAL_HISTORY_DELTA_BATCH_MAX_MUTATIONS) {
+            this.flushSubscription(subscription);
+            return;
+        }
+        if (subscription.flushTimer)
+            return;
+        subscription.flushTimer = setTimeout(() => this.flushSubscription(subscription), PERSONAL_HISTORY_DELTA_BATCH_WINDOW_MS);
+    }
+    flushSubscription(subscription) {
+        if (subscription.flushTimer) {
+            clearTimeout(subscription.flushTimer);
+            subscription.flushTimer = null;
+        }
+        if (subscription.pending.length === 0)
+            return;
+        const mutations = subscription.pending
+            .filter((mutation) => mutation.revision > subscription.lastSentRevision);
+        subscription.pending = [];
+        subscription.pendingBytes = 0;
+        if (mutations.length === 0)
+            return;
+        const toRevision = mutations[mutations.length - 1].revision;
+        this.client.sendEvent({
+            type: 'event',
+            event: 'session.body.delta',
+            payload: {
+                ...getPersonalSyncIdentity(this.store.daemonInstallationId),
+                sessionId: subscription.sessionId,
+                subscriptionId: subscription.subscriptionId,
+                fromRevision: subscription.lastSentRevision,
+                toRevision,
+                mutations: mutations.map((mutation) => ({
+                    ...mutation,
+                    subscriptionId: subscription.subscriptionId,
+                })),
+            },
+        });
+        recordPersonalSyncLocalMetric('historyDeltas');
+        recordPersonalSyncLocalMetric('historyBytesServed', Buffer.byteLength(JSON.stringify(mutations), 'utf8'));
+        subscription.lastSentRevision = toRevision;
+    }
+    requireSubscription(sessionId, subscriptionId) {
+        validateIdentity(sessionId, subscriptionId);
+        const subscription = this.subscriptions.get(subscriptionId);
+        if (!subscription || subscription.sessionId !== sessionId)
+            throw new Error('subscription_not_found');
+        return subscription;
+    }
+    updateSubscriptionMetric() {
+        setPersonalSyncLocalSubscriptions(this.subscriptions.size + this.replicaStreams.size);
+    }
+}
+function validateIdentity(sessionId, subscriptionId) {
+    if (typeof sessionId !== 'string' || !sessionId || typeof subscriptionId !== 'string' || !subscriptionId) {
+        throw new Error('invalid history subscription identity');
+    }
+}
+function validateStreamIdentity(appInstallationId, streamId, generation) {
+    if (typeof appInstallationId !== 'string' || !appInstallationId
+        || typeof streamId !== 'string' || !streamId
+        || !Number.isSafeInteger(generation) || generation < 1) {
+        throw new Error('invalid body replica stream identity');
+    }
+}
+function normalizeLimit(value, fallback) {
+    const limit = value ?? fallback;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > SESSION_HISTORY_LIMITS.maxPageMessages) {
+        throw new Error('invalid history limit');
+    }
+    return limit;
+}
+function normalizeSyncLimit(value) {
+    const limit = value ?? SESSION_HISTORY_LIMITS.maxDeltaMutations;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > SESSION_HISTORY_LIMITS.maxDeltaMutations) {
+        throw new Error('invalid history sync limit');
+    }
+    return limit;
+}