@abloatai/ablo 0.36.0 → 0.37.1

package/dist/sync/deltaPipeline.js

@@ -1,278 +0,0 @@
-/**
- * The pipeline that takes incoming deltas from the server and lands them in
- * local state. It has four stages: deduplicating deltas by state signature,
- * per-delta bookkeeping and enqueue, a debounce for live traffic, and a flush
- * that writes to the local store and then the in-memory pool. Every call it
- * makes back into the surrounding store — resolving state fields, identifying
- * custom entities, deduplicating, flushing, handling sync-group changes —
- * routes through the {@link DeltaPipelineContext} interface, so a subclass that
- * overrides any of those hooks still takes effect. The atomic frame-apply entry
- * point lives on the store and drives this pipeline through {@link enqueueDelta}
- * and {@link flushPendingDeltas}.
- */
-import { runInAction } from 'mobx';
-import { globalRuntime } from '../context.js';
-import { ModelScope } from '../InstanceCache.js';
-import { runStage, pluginsForStage, } from '../transaction/plugin.js';
-/**
- * Handles a sync-group ('G' or 'S') delta whose handler rejected after the
- * applied watermark had already advanced. That delta will never be redelivered,
- * so a failed security clear — revoked data that must not stay cached — would
- * otherwise fail silently. The safe fallback is blunt: drop the whole in-memory
- * pool and force a full re-bootstrap, rebuilding local state from the server.
- * It never throws, because it runs inside the pipeline's fire-and-forget path.
- */
-export function handleGroupHandlerFailure(ctx, delta, error) {
-    (ctx.runtime ?? globalRuntime).logger.error('Your access changed but cached data could not be cleared — resetting local data.', {
-        syncId: delta.id,
-        error: error instanceof Error ? error.message : String(error),
-    });
-    try {
-        ctx.objectPool.clear();
-    }
-    catch {
-        // In-memory clear must never mask the re-bootstrap below.
-    }
-    try {
-        ctx.forceFullRebootstrap();
-    }
-    catch {
-        // Best-effort: the reconnect/bootstrap cycle self-heals on next connect.
-    }
-}
-/** Builds a small signature of a delta's state fields, used to detect no-op duplicate deltas. */
-function extractStateSignature(ctx, delta) {
-    if (!delta.data || typeof delta.data !== 'object')
-        return null;
-    const data = typeof delta.data === 'string'
-        ? JSON.parse(delta.data)
-        : (delta.data);
-    // Generic state fields — subclasses can override getStateFields() for model-specific fields
-    const fieldsToCheck = ctx.getStateFields(delta.modelName);
-    const signature = {
-        actionType: delta.actionType,
-        modelName: delta.modelName,
-    };
-    for (const field of fieldsToCheck) {
-        if (field in data)
-            signature[field] = data[field];
-    }
-    return signature;
-}
-function isSameState(a, b) {
-    if (!a || !b)
-        return false;
-    const keys = Object.keys(a);
-    if (keys.length !== Object.keys(b).length)
-        return false;
-    return keys.every((k) => a[k] === b[k]);
-}
-/** Deduplicate deltas to the same entity — keep meaningful state transitions only */
-export function deduplicateDeltas(ctx, deltas) {
-    const byEntity = new Map();
-    for (const d of deltas) {
-        const key = `${d.modelName}:${d.modelId}`;
-        if (!byEntity.has(key))
-            byEntity.set(key, []);
-        byEntity.get(key).push(d);
-    }
-    const result = [];
-    for (const entityDeltas of byEntity.values()) {
-        const sorted = entityDeltas.sort((a, b) => a.id - b.id);
-        // DELETE wins — it's the final state
-        const del = sorted.find((d) => d.actionType === 'D');
-        if (del) {
-            result.push(del);
-            continue;
-        }
-        // Keep deltas that represent different states
-        const unique = [];
-        let prev = null;
-        for (const d of sorted) {
-            const sig = extractStateSignature(ctx, d);
-            if (!isSameState(prev, sig)) {
-                unique.push(d);
-                prev = sig;
-            }
-        }
-        if (unique.length > 0) {
-            result.push(...unique);
-        }
-        else {
-            // `sorted` is never empty (every byEntity bucket gets at least one
-            // delta pushed) — the guard only narrows the indexed access.
-            const last = sorted.at(-1);
-            if (last)
-                result.push(last);
-        }
-    }
-    return result.sort((a, b) => a.id - b.id);
-}
-/**
- * Performs per-delta bookkeeping and enqueues the delta. Returns `true` when
- * the delta was pushed onto `pendingDeltas` — a regular batchable insert,
- * update, covering, or delete that a later flush must drain — and `false` when
- * it was skipped as a duplicate, deferred into the bootstrap queue, or handled
- * immediately (a 'G'/'S' sync-group change). It does not schedule the flush
- * itself; the caller chooses whether to debounce live traffic or flush a
- * catch-up frame atomically.
- */
-export function enqueueDelta(ctx, delta, options = {}) {
-    // Dedup guard — skip already-processed deltas. The `applied` watermark is a
-    // valid skip threshold only for in-order live traffic; an authoritative
-    // catch-up frame bypasses it, so an out-of-order live delta that advanced the
-    // watermark can't cause the frame's lower ids to be dropped silently.
-    if (!options.authoritative && delta.id > 0 && delta.id <= ctx.highestProcessedSyncId) {
-        return false;
-    }
-    // Confirm awaiting transactions via sync ID threshold (before batching)
-    ctx.onDeltaReceived(delta.id, delta.transactionId, delta.correlationId);
-    // Queue during active bootstrap
-    if (ctx.bootstrapDeltaQueue !== null) {
-        ctx.bootstrapDeltaQueue.push(delta);
-        return false;
-    }
-    // Advance watermark
-    ctx.advanceApplied(delta.id);
-    // Sync group added — handle immediately. Accepts both the batched
-    // (addedGroups/removedGroups) and incremental (group/userId) payloads. This
-    // is deliberately not fire-and-forget: the watermark has already advanced, so
-    // a rejected handler (a failed security clear) must trigger the fallback
-    // rather than vanish.
-    if (delta.actionType === 'G') {
-        void ctx.handleSyncGroupChange(delta).catch((error) => {
-            handleGroupHandlerFailure(ctx, delta, error);
-        });
-        return false;
-    }
-    // Sync group removed — handle immediately. Clears affected local state
-    // and forces re-bootstrap with the updated group list. Same fallback:
-    // a failed revocation clear escalates instead of leaving revoked rows.
-    if (delta.actionType === 'S') {
-        void ctx.handleGroupRemoved(delta).catch((error) => {
-            handleGroupHandlerFailure(ctx, delta, error);
-        });
-        return false;
-    }
-    // Delete — run the cascade cancel immediately (O(1) through the foreign-key
-    // index; it must run before any later update on the same model lands, so
-    // pending update transactions for soon-deleted children don't race their
-    // parent's delete). The persistence and pool write still goes through the
-    // same batched path as updates: flushing each delete on its own produced one
-    // store write, one pool mutation, and one `models:changed` event per row, so
-    // deleting a parent with many children fanned out into many of each, whereas
-    // the batched path collapses them into one per flush. Deduplication in
-    // `flushPendingDeltas` handles an update-then-delete on the same model by
-    // replaying in arrival order.
-    if (delta.actionType === 'D') {
-        ctx.cascadeCancelTransactionsForDeletedParent(delta.modelName, delta.modelId);
-    }
-    // The delta is accepted and queued — the `receive` stage boundary.
-    runStage(ctx.stagePlugins ?? [], 'receive', { delta });
-    ctx.pendingDeltas.push(delta);
-    return true;
-}
-/** Debounce a flush for live single-delta traffic. */
-export function scheduleDeltaFlush(ctx) {
-    if (ctx.batchTimer)
-        clearTimeout(ctx.batchTimer);
-    if (ctx.pendingDeltas.length >= ctx.smartSyncOptions.maxBatchSize) {
-        void ctx.flushPendingDeltas().catch(ctx.handleFlushError);
-    }
-    else {
-        ctx.batchTimer = setTimeout(() => {
-            void ctx.flushPendingDeltas().catch(ctx.handleFlushError);
-        }, ctx.smartSyncOptions.batchingDelay);
-    }
-}
-/**
- * Flushes the queued deltas: deduplicates them, applies custom-entity deltas
- * straight to the pool, writes the rest to the local store and then the pool,
- * and advances the acknowledgement cursor once the store write has committed.
- */
-export async function flushPendingDeltas(ctx) {
-    if (ctx.pendingDeltas.length === 0)
-        return;
-    const stagePlugins = ctx.stagePlugins ?? [];
-    const deduplicatedDeltas = ctx.deduplicateDeltas(ctx.pendingDeltas);
-    runStage(stagePlugins, 'dedupe', { deltas: deduplicatedDeltas });
-    // Custom entities → apply straight to the pool, skipping the local store.
-    const customDeltas = deduplicatedDeltas.filter((d) => ctx.isCustomEntity(d.modelName));
-    if (customDeltas.length > 0) {
-        runInAction(() => {
-            for (const delta of customDeltas) {
-                const data = typeof delta.data === 'string'
-                    ? JSON.parse(delta.data)
-                    : (delta.data);
-                // 'C' (Covering) is treated identically to 'I' here — the client
-                // gained permission to see the entity, so we insert it into the
-                // pool as if newly created.
-                if (delta.actionType === 'I' || delta.actionType === 'U' || delta.actionType === 'C') {
-                    const existing = ctx.objectPool.get(delta.modelId);
-                    if (existing) {
-                        existing.updateFromData(data);
-                    }
-                    else {
-                        const model = ctx.createCustomEntity(delta.modelName, delta.modelId, data);
-                        if (model) {
-                            model.markAsPersisted();
-                            ctx.objectPool.add(model, ModelScope.live);
-                        }
-                    }
-                }
-                else if (delta.actionType === 'D') {
-                    ctx.objectPool.remove(delta.modelId);
-                }
-            }
-        });
-    }
-    // Regular deltas → the local store, then the pool.
-    // 'G' and 'S' deltas are handled earlier (handleSyncGroupChange /
-    // handleGroupRemoved) and never reach here, though the persistence
-    // signature accepts them defensively.
-    const regularDeltas = deduplicatedDeltas.filter((d) => !ctx.isCustomEntity(d.modelName));
-    const batch = await ctx.processDeltaBatch(regularDeltas.map((d) => ({
-        syncId: d.id,
-        actionType: d.actionType,
-        modelName: d.modelName,
-        modelId: d.modelId,
-        data: typeof d.data === 'string' ? JSON.parse(d.data) : d.data,
-        // Thread `transactionId` through so the receive layer can recognize
-        // echoes of locally-applied transactions and skip the pool mutation.
-        transactionId: d.transactionId,
-    })));
-    const dbResults = batch.results;
-    runStage(stagePlugins, 'persist', { deltas: regularDeltas });
-    // Apply the batch results to the in-memory graph. When a plugin has
-    // declared the `apply` stage, its handlers ARE the apply — the
-    // materialiser attached where it said it would. The direct call is the
-    // bridge for stores constructed without plugins (subclasses, tests),
-    // whose own apply is the whole pipeline.
-    if (pluginsForStage(stagePlugins, 'apply').length > 0) {
-        runStage(stagePlugins, 'apply', { changes: dbResults });
-    }
-    else {
-        ctx.applyDeltaBatchToPool(dbResults);
-    }
-    // Acknowledge and advance the sync cursor, gated on persistence.
-    //
-    // We must acknowledge `persistedSyncId` — the high-water mark of deltas whose
-    // store transaction actually committed — not the input batch's last delta id.
-    // Acknowledging the input range would advance the server's view past deltas
-    // that never persisted; the next catch-up would then send the advanced cursor,
-    // the server would answer "you're up to date", and the unpersisted delta would
-    // be lost. The cursor and the persisted state must move together.
-    const persistedSyncId = batch.persistedSyncId;
-    if (persistedSyncId > ctx.lastAckedId) {
-        ctx.acknowledge(persistedSyncId);
-        ctx.advancePersisted(persistedSyncId);
-        runStage(stagePlugins, 'acknowledge', { syncId: persistedSyncId });
-    }
-    // Cache invalidation happens automatically via the 'models:changed' event.
-    runStage(stagePlugins, 'notify', { changes: dbResults });
-    ctx.pendingDeltas = [];
-    if (ctx.batchTimer) {
-        clearTimeout(ctx.batchTimer);
-        ctx.batchTimer = null;
-    }
-}

package/dist/sync/groupChange.d.ts

@@ -1,116 +0,0 @@
-/**
- * Handles the delta types that change which sync groups a session can see. A
- * sync group is a fan-out scope the server uses to decide which entities a
- * client receives. When a session's membership changes, these handlers update
- * the client's subscription list; when access is revoked, they clear cached
- * data and trigger a full re-bootstrap so revoked rows cannot linger on the
- * device.
- *
- * Every handler takes a {@link GroupChangeContext}, the narrow facade through
- * which it reaches the client's local storage and connection lifecycle hooks.
- */
-import type { RuntimeContext } from '../RuntimeContext.js';
-import type { SyncDelta, SyncGroupChangePayload, GroupAddedPayload } from './SyncWebSocket.js';
-/**
- * The collaborators the group-change handlers depend on. It gathers the
- * client's local storage, in-memory pool, and connection lifecycle hooks
- * behind one narrow interface, so the handlers stay decoupled from the larger
- * store that supplies them.
- */
-export interface GroupChangeContext {
-    /**
-     * Local persistence. Performs the security clear, reads and writes the
-     * subscription metadata, and sets the flag that forces a full bootstrap.
-     */
-    readonly database: {
-        clear(): Promise<void>;
-        getWorkspaceMetadata(): Promise<{
-            subscribedSyncGroups?: string[];
-        } | null>;
-        updateWorkspaceMetadata(metadata: {
-            subscribedSyncGroups: string[];
-        }): Promise<void>;
-        markRequiresFullBootstrap(): void;
-    };
-    /** The in-memory object cache, cleared alongside local storage when access is revoked. */
-    readonly objectPool: {
-        clear(): void;
-    };
-    /** Returns the sync groups the live connection is currently subscribed to. */
-    getSubscribedSyncGroups(): readonly string[];
-    /**
-     * Returns the session's authoritative sync groups, resolved from the current
-     * user context via {@link resolveSyncGroups}; null when no user context has
-     * been set yet.
-     */
-    getCurrentSyncGroups(): readonly string[] | null;
-    /**
-     * Returns the session's bootstrap mode. A value of 'none' means the
-     * participant never pulls a baseline, so it never re-bootstraps.
-     */
-    getBootstrapMode(): 'full' | 'none' | undefined;
-    /** Disconnects the live connection, one step of the forced re-bootstrap cycle. */
-    disconnectWebSocket(): void;
-    /** Emits a connection lifecycle event to any registered listener; a no-op when none is set. */
-    emitConnectionEvent(event: string): void;
-    handleGroupAdded(payload: GroupAddedPayload, syncId: number): Promise<void>;
-    computeUpdatedSyncGroups(payload: SyncGroupChangePayload): string[];
-    forceFullRebootstrap(): void;
-    /** The owning client's runtime. Defaults to the module-global bridge. */
-    readonly runtime?: RuntimeContext;
-}
-/**
- * Handles a 'G' (group-change) delta. The server sends two shapes of this
- * delta, told apart by the payload:
- *
- *   Incremental — `{ group, userId }`: the recipient was added to a single
- *   sync group. No re-bootstrap follows; the newly visible entities arrive as
- *   ordinary 'C' (covering) deltas through the normal insert path.
- *
- *   Full diff — `{ addedGroups, removedGroups }`: one delta carrying the whole
- *   membership change. This forces a full re-bootstrap (disconnect, reconnect,
- *   and refetch), clearing cached data first if any group was removed.
- */
-export declare function handleSyncGroupChange(ctx: GroupChangeContext, delta: SyncDelta): Promise<void>;
-/**
- * Handles an incremental group-added delta. It records the new sync group in
- * the subscription metadata without forcing a re-bootstrap; the server then
- * sends a 'C' (covering) delta for each newly visible entity, which flows
- * through the normal insert path.
- */
-export declare function handleGroupAdded(ctx: GroupChangeContext, payload: GroupAddedPayload, syncId: number): Promise<void>;
-/**
- * Handles an 'S' (group-removed) delta, which signals the recipient has lost
- * access to a sync group. The client does not track which entities belong to
- * which group, so it cannot purge only the affected rows; instead it clears
- * local state and forces a re-bootstrap with the updated group list.
- */
-export declare function handleGroupRemoved(ctx: GroupChangeContext, delta: SyncDelta): Promise<void>;
-/** Computes the new sync-group set after applying the additions and removals in a diff. */
-export declare function computeUpdatedSyncGroups(ctx: GroupChangeContext, payload: SyncGroupChangePayload): string[];
-/**
- * Forces a full re-bootstrap by marking local storage as needing one,
- * disconnecting, and emitting a connection lifecycle event that the reconnect
- * path acts on. Does nothing for participants whose bootstrap mode is 'none':
- * they never pull a baseline, so after a trigger such as a sync-group shrink or
- * an access revocation they rely on covering deltas to repopulate the data they
- * subscribe to.
- */
-export declare function forceFullRebootstrap(ctx: GroupChangeContext): void;
-/**
- * Resolves the sync-group list this session subscribes to, and is the single
- * place that decision is made. The server-issued `context.syncGroups` is
- * authoritative; when it is absent, the session subscribes to no explicit
- * groups. {@link checkSyncGroupShrinkage} and connection setup both read
- * through here, so the live subscription and the access-revocation check can
- * never disagree.
- */
-export declare function resolveSyncGroups(context: {
-    syncGroups?: readonly string[];
-}): readonly string[];
-/**
- * Compares the session's current sync groups against the set stored from the
- * last session. If any group is now missing, access has narrowed, so this
- * clears cached data and forces a full bootstrap before recording the new set.
- */
-export declare function checkSyncGroupShrinkage(ctx: GroupChangeContext): Promise<void>;

package/dist/sync/groupChange.js

@@ -1,244 +0,0 @@
-/**
- * Handles the delta types that change which sync groups a session can see. A
- * sync group is a fan-out scope the server uses to decide which entities a
- * client receives. When a session's membership changes, these handlers update
- * the client's subscription list; when access is revoked, they clear cached
- * data and trigger a full re-bootstrap so revoked rows cannot linger on the
- * device.
- *
- * Every handler takes a {@link GroupChangeContext}, the narrow facade through
- * which it reaches the client's local storage and connection lifecycle hooks.
- */
-import { globalRuntime } from '../context.js';
-/** The context's runtime, falling back to the module-global bridge. */
-const runtimeOf = (ctx) => ctx.runtime ?? globalRuntime;
-/**
- * Marker returned when a group-change payload cannot be parsed, kept distinct
- * from a valid null or absent payload, which the handlers accept normally.
- */
-const MALFORMED_PAYLOAD = Symbol('malformed-group-change-payload');
-/**
- * Parses a group-change delta payload without ever throwing. The server sends
- * these as JSON strings. If a frame is corrupt, this returns
- * {@link MALFORMED_PAYLOAD} rather than raising, because an error escaping here
- * would leave the delta pipeline after the watermark has already advanced. The
- * delta is never re-delivered, so the security clear it carried would be lost.
- */
-function parseGroupChangePayload(delta, runtime) {
-    if (typeof delta.data !== 'string')
-        return delta.data;
-    try {
-        return JSON.parse(delta.data);
-    }
-    catch (error) {
-        runtime.logger.debug('[BaseSyncedStore] Malformed group-change payload', {
-            syncId: delta.id,
-            actionType: delta.actionType,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return MALFORMED_PAYLOAD;
-    }
-}
-/**
- * Fallback for a group-change delta that could not be read. Because we know
- * access changed but not how, this treats it as a revocation: it clears cached
- * data from both local storage and the in-memory pool, then forces a full
- * re-bootstrap from the server.
- */
-async function clearForUnknownGroupChange(ctx, delta, kind) {
-    runtimeOf(ctx).logger.debug(`[BaseSyncedStore] Unreadable ${kind} payload — clearing cached data and re-bootstrapping`, { syncId: delta.id });
-    // Revoked data must not persist if the device goes offline before the
-    // re-bootstrap, the same reasoning as the explicit removed-groups path.
-    await ctx.database.clear();
-    ctx.objectPool.clear();
-    ctx.forceFullRebootstrap();
-}
-/**
- * Handles a 'G' (group-change) delta. The server sends two shapes of this
- * delta, told apart by the payload:
- *
- *   Incremental — `{ group, userId }`: the recipient was added to a single
- *   sync group. No re-bootstrap follows; the newly visible entities arrive as
- *   ordinary 'C' (covering) deltas through the normal insert path.
- *
- *   Full diff — `{ addedGroups, removedGroups }`: one delta carrying the whole
- *   membership change. This forces a full re-bootstrap (disconnect, reconnect,
- *   and refetch), clearing cached data first if any group was removed.
- */
-export async function handleSyncGroupChange(ctx, delta) {
-    const raw = parseGroupChangePayload(delta, runtimeOf(ctx));
-    if (raw === MALFORMED_PAYLOAD) {
-        // The payload is unreadable, so we cannot tell which groups changed, and
-        // this delta will never be re-delivered because the watermark has already
-        // advanced. Fall back to the safe direction: assume a revocation, clear
-        // cached data, and rebuild from the server rather than throwing.
-        await clearForUnknownGroupChange(ctx, delta, 'sync-group change');
-        return;
-    }
-    const rawObj = (raw ?? {});
-    // Detect incremental payload shape: { group, userId }
-    if (typeof rawObj.group === 'string' && typeof rawObj.userId === 'string') {
-        const incremental = {
-            group: rawObj.group,
-            userId: rawObj.userId,
-        };
-        await ctx.handleGroupAdded(incremental, delta.id);
-        return;
-    }
-    // Full-diff payload: { addedGroups, removedGroups }
-    const payload = {
-        removedGroups: rawObj.removedGroups ?? [],
-        addedGroups: rawObj.addedGroups ?? [],
-    };
-    runtimeOf(ctx).logger.info('[BaseSyncedStore] Sync group change received (legacy)', {
-        removedGroups: payload.removedGroups,
-        addedGroups: payload.addedGroups,
-        syncId: delta.id,
-    });
-    // If any groups were removed, clear cached data immediately so revoked data
-    // cannot persist should the device go offline before the re-bootstrap
-    // completes.
-    if (payload.removedGroups.length > 0) {
-        await ctx.database.clear();
-        ctx.objectPool.clear();
-        runtimeOf(ctx).logger.info('[BaseSyncedStore] Cleared cached data due to revoked sync groups', {
-            removedGroups: payload.removedGroups,
-        });
-    }
-    const updatedGroups = ctx.computeUpdatedSyncGroups(payload);
-    await ctx.database.updateWorkspaceMetadata({ subscribedSyncGroups: updatedGroups });
-    ctx.forceFullRebootstrap();
-}
-/**
- * Handles an incremental group-added delta. It records the new sync group in
- * the subscription metadata without forcing a re-bootstrap; the server then
- * sends a 'C' (covering) delta for each newly visible entity, which flows
- * through the normal insert path.
- */
-export async function handleGroupAdded(ctx, payload, syncId) {
-    runtimeOf(ctx).logger.info('[BaseSyncedStore] Group added (incremental)', {
-        group: payload.group,
-        syncId,
-    });
-    const current = new Set(ctx.getSubscribedSyncGroups());
-    current.add(payload.group);
-    await ctx.database.updateWorkspaceMetadata({ subscribedSyncGroups: Array.from(current) });
-    // No forceFullRebootstrap() here; the covering deltas will bring the entities.
-}
-/**
- * Handles an 'S' (group-removed) delta, which signals the recipient has lost
- * access to a sync group. The client does not track which entities belong to
- * which group, so it cannot purge only the affected rows; instead it clears
- * local state and forces a re-bootstrap with the updated group list.
- */
-export async function handleGroupRemoved(ctx, delta) {
-    const raw = parseGroupChangePayload(delta, runtimeOf(ctx));
-    if (raw === MALFORMED_PAYLOAD) {
-        // The payload is unreadable: access was revoked but we cannot tell which
-        // group. Fall back to a full clear, the safe direction for an
-        // access-revocation delta, rather than throwing.
-        await clearForUnknownGroupChange(ctx, delta, 'group-removed');
-        return;
-    }
-    const rawObj = (raw ?? {});
-    const groupKey = typeof rawObj.group === 'string' ? rawObj.group : undefined;
-    if (!groupKey) {
-        runtimeOf(ctx).logger.debug('[BaseSyncedStore] Group removed delta missing group key', {
-            syncId: delta.id,
-        });
-        return;
-    }
-    runtimeOf(ctx).logger.info('[BaseSyncedStore] Group removed', {
-        group: groupKey,
-        syncId: delta.id,
-    });
-    // Clear cached data before the re-bootstrap so revoked-group data cannot
-    // persist if the device goes offline between receiving this delta and
-    // completing the re-bootstrap.
-    await ctx.database.clear();
-    ctx.objectPool.clear();
-    // Update subscription metadata so the re-bootstrap fetches the
-    // correct set of groups.
-    const current = new Set(ctx.getSubscribedSyncGroups());
-    current.delete(groupKey);
-    await ctx.database.updateWorkspaceMetadata({ subscribedSyncGroups: Array.from(current) });
-    ctx.forceFullRebootstrap();
-}
-/** Computes the new sync-group set after applying the additions and removals in a diff. */
-export function computeUpdatedSyncGroups(ctx, payload) {
-    const current = new Set(ctx.getSubscribedSyncGroups());
-    for (const g of payload.removedGroups)
-        current.delete(g);
-    for (const g of payload.addedGroups)
-        current.add(g);
-    return Array.from(current);
-}
-/**
- * Forces a full re-bootstrap by marking local storage as needing one,
- * disconnecting, and emitting a connection lifecycle event that the reconnect
- * path acts on. Does nothing for participants whose bootstrap mode is 'none':
- * they never pull a baseline, so after a trigger such as a sync-group shrink or
- * an access revocation they rely on covering deltas to repopulate the data they
- * subscribe to.
- */
-export function forceFullRebootstrap(ctx) {
-    if (ctx.getBootstrapMode() === 'none') {
-        runtimeOf(ctx).logger.info('[BaseSyncedStore] forceFullRebootstrap skipped (bootstrapMode=none)');
-        return;
-    }
-    ctx.database.markRequiresFullBootstrap();
-    ctx.disconnectWebSocket();
-    ctx.emitConnectionEvent('WS_DISCONNECTED');
-}
-/**
- * Resolves the sync-group list this session subscribes to, and is the single
- * place that decision is made. The server-issued `context.syncGroups` is
- * authoritative; when it is absent, the session subscribes to no explicit
- * groups. {@link checkSyncGroupShrinkage} and connection setup both read
- * through here, so the live subscription and the access-revocation check can
- * never disagree.
- */
-export function resolveSyncGroups(context) {
-    if (context.syncGroups && context.syncGroups.length > 0) {
-        return context.syncGroups;
-    }
-    return [];
-}
-/**
- * Compares the session's current sync groups against the set stored from the
- * last session. If any group is now missing, access has narrowed, so this
- * clears cached data and forces a full bootstrap before recording the new set.
- */
-export async function checkSyncGroupShrinkage(ctx) {
-    const currentSyncGroups = ctx.getCurrentSyncGroups();
-    if (!currentSyncGroups)
-        return;
-    try {
-        const metadata = await ctx.database.getWorkspaceMetadata();
-        const stored = metadata?.subscribedSyncGroups ?? [];
-        if (stored.length === 0)
-            return;
-        const currentGroups = new Set(currentSyncGroups);
-        const removedGroups = stored.filter((g) => !currentGroups.has(g));
-        if (removedGroups.length > 0) {
-            runtimeOf(ctx).logger.info('[BaseSyncedStore] Sync groups shrank — forcing full bootstrap', {
-                removedGroups,
-                storedCount: stored.length,
-                currentCount: currentGroups.size,
-            });
-            // Clear cached data before the re-bootstrap so revoked-group data cannot
-            // persist if the device goes offline first.
-            await ctx.database.clear();
-            ctx.objectPool.clear();
-            ctx.database.markRequiresFullBootstrap();
-        }
-        await ctx.database.updateWorkspaceMetadata({
-            subscribedSyncGroups: Array.from(currentGroups),
-        });
-    }
-    catch (error) {
-        runtimeOf(ctx).logger.debug('[BaseSyncedStore] Failed to check sync group shrinkage', {
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-}