@rapidmx/activesync-plugin 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/lib/commands/SyncCommand.js

@@ -13,59 +13,99 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 ///////////////////////////////////////////////////////////////////////////////
 import { ApiError, ObjectDecorators } from "@rapidrest/core";
 import { ACLAction, ACLUtils, ApiErrorMessages, ApiErrors, RepoUtils, } from "@rapidrest/service-core";
-import { RecoverableRepoUtils } from "@rapidmx/restapi";
+import { AuditAction, findOrCreateWellKnownFolder, FolderType, RecoverableRepoUtils } from "@rapidmx/restapi";
 import { WbxmlCodePage } from "../codec/WbxmlCodePages.js";
 import { childText, element, findChild, findChildren, textElement } from "../codec/WbxmlElement.js";
-import { computeChanges, formatSyncKey, persistDeviceSyncState, resolveSyncKey } from "../EasSyncKeyUtils.js";
-const { Config, Init, Inject } = ObjectDecorators;
-/** Caps how many item changes are enumerated per `Sync` round - a real device-visible "MoreAvailable" trigger
- * for a busy folder, not a real-world binding constraint (unlike `FolderSyncCommand`'s much smaller folder
- * hierarchy, an Inbox can easily exceed this in one round). */
+import { formatSyncKey } from "../EasSyncKeyUtils.js";
+import { classForFolderType, cloneWorkingState, enumerateCollection, filterPredicate, roundRecord, workingStateFromRound, workingStateFromRow, } from "../EasCollectionSync.js";
+import { clearHeldSet, INLINE_HELD_LIMIT, loadHeldSet, saveHeldSet } from "../EasCollectionStore.js";
+import { hasLiveSendLease, planMessageMove } from "../MessageMoveRules.js";
+import { asEntity } from "../RestapiCompat.js";
+import { EasCollectionLease } from "../EasCollectionLease.js";
+import { EasAuditLog } from "../EasAuditLog.js";
+const { Config, Init, Inject, Logger } = ObjectDecorators;
+/** Default most item changes reported per collection per `Sync` round. */
 const DEFAULT_WINDOW_SIZE = 100;
+/** [MS-ASCMD]'s own ceiling for `WindowSize`. */
+const MAX_WINDOW_SIZE = 512;
+/** Most `<Collection>`s one `Sync` request may carry - more is answered with a top-level Status 4. */
+export const MAX_SYNC_COLLECTIONS = 300;
+/** Most client `Add`/`Change`/`Delete` commands one collection of a `Sync` request may carry - more is answered
+ * with that collection's Status 4, without applying any of them. */
+export const MAX_SYNC_COMMANDS_PER_COLLECTION = 512;
+/** Rows read per round from the stream of items outside a collection's folder (see `enumerateCollection`). */
+const DEFAULT_MOVE_SCAN_LIMIT = 1000;
+/** Held ids checked against the store per caught-up round (see `enumerateCollection`'s reconcile). */
+const DEFAULT_RECONCILE_LIMIT = 100;
+/** Slack subtracted from "now" when a collection is (re)started, for the out-of-folder cursor. */
+const MOVE_CURSOR_SLACK_MS = 60000;
+/** How long a `Sync` waits for another request's lease on the same collection before answering Status 16. */
+const LEASE_WAIT_MS = 15000;
+/** How long a collection lease lives in Redis if its holder dies without releasing it. */
+const LEASE_TTL_MS = 120000;
+/** [MS-ASCMD] `Sync` Status values this command reports beyond success. */
+const STATUS_INVALID_SYNC_KEY = "3";
+const STATUS_SERVER_ERROR = "5";
+const STATUS_RETRY = "16";
 /**
- * Handles EAS `Sync`: enumerates `Add`/`Change`/`Delete`s for a single folder's contents since the device's last
- * `Sync` of that folder, using the same watermark-based cursor mechanism `FolderSyncCommand` uses (via
- * `EasSyncKeyUtils`), scoped by `folderUid` instead of `mailboxUid`, and keyed per-folder in
- * `DeviceSyncState.folderSyncKeys` (the `CollectionId` a client sends *is* the `folderUid` - this library never
- * invents a separate collection identifier).
+ * Handles EAS `Sync` for `Email`/`Contacts`/`Calendar`/`Tasks` folders.
  *
- * **Multi-collection requests**: every `<Collection>` in a request's `<Collections>` is processed and gets its
- * own `<Collection>` entry in the response, each with its own independent `SyncKey`/`Status` - a client
- * syncing several folders in one round trip (the common case once the initial per-folder backlog is done)
- * gets one response covering all of them. All per-collection `SyncKey`/remembered-`Class` writes for the whole
- * request are batched into a single `persistDeviceSyncState` call after every collection has been processed
- * (never one call per collection) - see `EasSyncKeyUtils.persistDeviceSyncState`'s own doc comment for why a
- * second write to the same `DeviceSyncState` within one request must never be built off a stale copy.
+ * **Per-collection state** lives in its own `EasCollectionState` row per (mailbox, device, folder) - see that
+ * model - rather than in `DeviceSyncState`, so concurrent `Sync`s of different folders never contend for one row.
+ * Besides the issued `SyncKey`, the row records exactly which items the device holds (inline in `serverIds` while
+ * small, in `EasCollectionChunk` rows once large - see `EasCollectionStore`). That is what makes the reported
+ * commands correct rather than guessed: an item the device doesn't hold is always an `Add` (including on the first
+ * round after `SyncKey 0`), an item it holds is a `Change`, and an item it holds that has been deleted *or moved to
+ * another folder* is a `Delete` - see `EasCollectionSync.enumerateCollection`.
  *
- * **`Class` is only required on a collection's first (`SyncKey "0"`) request**, per `[MS-ASCMD]` - once seen,
- * it's remembered in `DeviceSyncState.folderCollectionClasses` (keyed by `folderUid`) so a later request may
- * omit it; omitting it for a folder never previously synced still gets `Status 4` (nothing to fall back to).
+ * **One round per collection at a time**: each collection's round runs under a lease on (mailbox, device, folder)
+ * (`EasCollectionLease`: in-process, plus Redis `datastores:cache` across server copies when configured), and its
+ * state is read only once the lease is held - a second `Sync` of the same collection waits for the first to finish
+ * and then sees its result (typically answering the now-previous `SyncKey` as a retry), instead of both computing a
+ * round from the same state. A lease not acquired within `LEASE_WAIT_MS` is answered with Status 16 (retry).
  *
- * **Every `CollectionId` is ACL-checked against the caller before it's touched**: `processCollection()` requires
- * `ACLAction.READ` on the folder before enumerating or accepting any Commands for it at all (a folder the caller
- * can't read is reported the same as an unrecognized collection - Status `4` - rather than leaking whether it
- * exists); `applyAdd`/`applyChange`/`applyDelete` additionally require `CREATE`/`UPDATE`/`DELETE` respectively,
- * and `applyChange`/`applyDelete` re-verify the resolved item's own `folderUid` actually matches the collection
- * being synced (treating a mismatch identically to "not found" - Status `8` - never revealing that the
- * `ServerId` resolves to something real elsewhere). Without this, a client could supply any other mailbox's
- * folder/item uid as its own `CollectionId`/`ServerId` and read or mutate that mailbox's data directly - the
- * same ownership-verification-after-an-`ignoreACL`-lookup pattern `ItemOperationsCommand`/`MoveItemsCommand`
- * already use, applied consistently here too.
+ * **Round order**: the client's own `Commands` are applied first, then server changes are enumerated. The device's
+ * own writes are not echoed back: each successful `Add`/`Change` records the resulting `dateModified` in the row's
+ * `echoes`, and a changed row still carrying exactly that timestamp is skipped. The cursor itself only ever advances
+ * past rows actually enumerated, never past a pending server change.
  *
- * **Pragmatic subset, deliberately not the full MS-ASCMD `Sync` surface**:
- * - **Client-originated `Add`/`Change`/`Delete` commands are accepted for every collection type**, including
- * `Email` (a device creating/editing a Draft, or deleting a message locally - see `applyAdd`/`applyChange`/
- * `applyDelete`). `[MS-ASCMD]` itself disallows `Add`/`Change` for any *non-draft* `Email` item - this library
- * doesn't verify a Sync `Email` Add/Change actually targets the caller's own Drafts folder *specifically*
- * (only that it's a folder the caller actually owns/can write to - see above), matching how Contacts/Calendar/
- * Tasks folder targeting is equally unchecked beyond ownership elsewhere. A collection whose adapter has no
- * `fromApplicationData` at all would get Status `6` for `Add`/`Change` instead, but every adapter today
- * implements it. Per `[MS-ASCMD]`'s own "Add (Sync)"/"Status (Sync)" pages: `Add` always gets a `Responses`
- * entry (it must report the assigned `ServerId`); `Change`/`Delete` only get one on **failure** - a silent
- * success means "assume it worked."
- * - Only a body preview is returned per item (see `EmailSyncAdapter`'s own doc comment) - full body content is
- * fetched separately via `ItemOperationsCommand`. A Draft's `Email` Add/Change is plain-text-only, with no
- * attachment support (mirrors `ComposeMailCommand`'s own already-documented attachment gap).
+ * **Lost state**: a round's state that can't be saved is answered with the collection's Status 3 (and a failed
+ * `SyncKey 0` restart with Status 5), never with a `SyncKey` the server doesn't have - the device re-syncs from
+ * scratch instead of continuing from a key whose held set was never recorded.
+ *
+ * **Retries**: a client that never received a response re-sends the `SyncKey` it still holds. The row keeps the
+ * previous round's key and delta (`previous`), so that key is accepted and the round is recomputed from the state
+ * before it; an `Add` re-sent with the same `ClientId` is answered with the item created the first time, and a
+ * `Delete` of an item that round already removed succeeds silently.
+ *
+ * **Options honoured**: `WindowSize` (capped by `mail:eas:sync_window_size` and 512), `FilterType` (age window for
+ * `Email`/`Calendar`, incomplete-only for `Tasks`; applied to items the device doesn't hold yet). A collection
+ * started without `Options` has no filter recorded, and the first `FilterType` sent while the device still holds
+ * nothing is adopted (clients commonly send `Options` only from the second request on); a `FilterType` differing
+ * from the recorded one otherwise gets Status 3 so the client re-syncs from 0. `DeletesAsMoves` (default `true`: an
+ * `Email` delete moves the message to Deleted Items; a delete inside Deleted Items, or with `DeletesAsMoves` `0`,
+ * deletes it) and `GetChanges` `0` (no server changes this round).
+ *
+ * **Meetings**: a device deleting or editing an attendee's copy of someone else's meeting never makes restapi's
+ * `MeetingSchedulingJob` send cancellations/invitations as the organizer - see `CalendarSyncAdapter.beforeDelete`
+ * and its `fromApplicationData`.
+ *
+ * **Access**: every `CollectionId` needs `READ` on the folder (otherwise Status 4, indistinguishable from an unknown
+ * collection); `Add`/`Change`/`Delete` additionally need `CREATE`/`UPDATE`/`DELETE`, and a `ServerId` that resolves
+ * to an item outside the synced folder is reported as not found (Status 8). An `Email` `Add` is only accepted in
+ * a Drafts folder ([MS-ASCMD]: no non-draft email may be added by a client), and a new item's `mailboxUid` is the
+ * folder's own mailbox, so an item added to a shared folder belongs to that folder's mailbox. An `Email` body can only
+ * be changed on a genuine draft (`EmailSyncAdapter`), and a delete-as-move out of Outbox cancels the scheduled send
+ * (`MessageMoveRules.planMessageMove`; Status 6 once the message was relayed), and no delete at all happens while a send of
+ * the message is in flight (`hasLiveSendLease`, Status 6). Every update is version-checked on both
+ * backends (`asEntity`).
+ *
+ * **Audit** (`EasAuditLog`), only in a mailbox the caller doesn't own (restapi's `isNonOwnerAccess()` - an administrator
+ * or a delegate syncing a shared folder), and only for `Email`: a round that sends `Add`/`Change` items records one
+ * `MESSAGE_CONTENT_ACCESSED` entry for the collection listing the sent message uids (at most a window's worth), rather
+ * than one per row; each successful client `Delete` records one `MESSAGE_DELETE` entry, as restapi's REST delete does.
+ *
+ * Per `[MS-ASCMD]`, `Add` always gets a `Responses` entry; `Change`/`Delete` only on failure.
  *
  * @author Jean-Philippe Steinmetz
  */
@@ -73,6 +113,9 @@ export class SyncCommand {
     constructor() {
         this.command = "Sync";
         this.windowSize = DEFAULT_WINDOW_SIZE;
+        this.moveScanLimit = DEFAULT_MOVE_SCAN_LIMIT;
+        this.reconcileLimit = DEFAULT_RECONCILE_LIMIT;
+        this.leaseWaitMs = LEASE_WAIT_MS;
         this.repos = new Map();
         this.adapters = new Map();
     }
@@ -81,11 +124,21 @@ export class SyncCommand {
             name: this.mailboxClass.name,
             args: [this.mailboxClass],
         });
+        this.folderRepo = await this._objectFactory.newInstance(RecoverableRepoUtils, {
+            name: this.folderClass.name,
+            args: [this.folderClass],
+        });
+        this.collectionStateRepo = await this._objectFactory.newInstance(RepoUtils, {
+            name: this.collectionStateClass.name,
+            args: [this.collectionStateClass],
+        });
+        this.collectionChunkRepo = await this._objectFactory.newInstance(RepoUtils, {
+            name: this.collectionChunkClass.name,
+            args: [this.collectionChunkClass],
+        });
         for (const [collectionClass, binding] of Object.entries(this.collectionBindings)) {
-            // RecoverableRepoUtils, not plain RepoUtils: SyncCommand now originates its own deletes
-            // (`applyDelete`) - without it, a soft-delete here wouldn't bump `dateModified`/`version`,
-            // breaking this exact class's own watermark-based deletion detection for anything deleted via
-            // Sync instead of the REST API. The same fix `BaseMapiEmsmdbRoute.ts` already needed for MAPI.
+            // RecoverableRepoUtils: a soft-delete must bump `dateModified`/`version`, or the change stream this
+            // class enumerates would never see it.
             this.repos.set(collectionClass, await this._objectFactory.newInstance(RecoverableRepoUtils, {
                 name: binding.entityClass.name,
                 args: [binding.entityClass],
@@ -93,22 +146,24 @@ export class SyncCommand {
             this.adapters.set(collectionClass, await this._objectFactory.newInstance(binding.adapterClass));
         }
     }
-    /** Resolves the caller's own `Mailbox` at most once per request, and only if actually needed - most `Sync`
-     * requests contain no client-originated `Add` at all, so most requests never pay this extra round trip. */
-    mailboxLoader(ctx) {
+    get chunkStore() {
+        return { repo: this.collectionChunkRepo, chunkClass: this.collectionChunkClass };
+    }
+    /** Resolves a mailbox at most once per request, and only if actually needed. */
+    mailboxLoader(mailboxUid) {
         let cached;
         return async () => {
             if (!cached) {
-                cached = await this.mailboxRepo.findOne(ctx.mailboxUid, { ignoreACL: true });
+                cached = await this.mailboxRepo.findOne(mailboxUid, { ignoreACL: true });
                 if (!cached) {
-                    throw new ApiError(ApiErrors.NOT_FOUND, 404, "The caller's own mailbox no longer exists.");
+                    throw new ApiError(ApiErrors.NOT_FOUND, 404, "The mailbox no longer exists.");
                 }
             }
             return cached;
         };
     }
     async handle(ctx) {
-        if (!this.aclUtils) {
+        if (!this.aclUtils || !this.folderRepo || !this.collectionStateRepo || !this.collectionChunkRepo) {
             throw new ApiError(ApiErrors.INTERNAL_ERROR, 500, ApiErrorMessages.INTERNAL_ERROR);
         }
         const collections = ctx.request ? findChild(ctx.request, "Collections") : undefined;
@@ -116,157 +171,279 @@ export class SyncCommand {
         if (collectionEls.length === 0) {
             return element(WbxmlCodePage.AirSync, "Sync", [textElement(WbxmlCodePage.AirSync, "Status", "3")]);
         }
+        if (collectionEls.length > MAX_SYNC_COLLECTIONS) {
+            return element(WbxmlCodePage.AirSync, "Sync", [textElement(WbxmlCodePage.AirSync, "Status", "4")]);
+        }
+        const requestWindowSize = childText(ctx.request, "WindowSize");
+        const getMailbox = this.mailboxLoader(ctx.mailboxUid);
+        const audit = new EasAuditLog({ objectFactory: this._objectFactory, auditLogClass: this.auditLogClass, mailboxRepo: this.mailboxRepo, config: this.config, logger: this.logger }, ctx, this.command);
         const collectionElements = [];
-        // Accumulated across every collection below, then written in exactly ONE persistDeviceSyncState call
-        // after the loop - never one call per collection (see this class's own doc comment on why).
-        let folderSyncKeys;
-        let folderCollectionClasses;
-        const getMailbox = this.mailboxLoader(ctx);
         for (const collectionEl of collectionEls) {
-            const result = await this.processCollection(ctx, collectionEl, getMailbox);
-            collectionElements.push(result.collectionElement);
-            if (result.folderUid && result.newSyncKey) {
-                folderSyncKeys = {
-                    ...(folderSyncKeys ?? ctx.deviceSyncState.folderSyncKeys),
-                    [result.folderUid]: result.newSyncKey,
-                };
-            }
-            if (result.folderUid && result.rememberedClass) {
-                folderCollectionClasses = {
-                    ...(folderCollectionClasses ?? ctx.deviceSyncState.folderCollectionClasses ?? {}),
-                    [result.folderUid]: result.rememberedClass,
-                };
-            }
+            collectionElements.push(await this.processCollection(ctx, collectionEl, getMailbox, requestWindowSize, audit));
         }
-        if (folderSyncKeys || folderCollectionClasses) {
-            await persistDeviceSyncState(ctx.deviceSyncState, ctx.deviceSyncStateRepo, {
-                ...(folderSyncKeys ? { folderSyncKeys } : {}),
-                ...(folderCollectionClasses ? { folderCollectionClasses } : {}),
-            });
-        }
-        return element(WbxmlCodePage.AirSync, "Sync", [
-            element(WbxmlCodePage.AirSync, "Collections", collectionElements),
-        ]);
+        return element(WbxmlCodePage.AirSync, "Sync", [element(WbxmlCodePage.AirSync, "Collections", collectionElements)]);
     }
-    /** Processes one `<Collection>` from the request into its own `<Collection>` response element, plus (when
-     * this round advanced anything) the `folderUid`/new `SyncKey`/remembered `Class` for `handle()` to fold
-     * into its single end-of-request `persistDeviceSyncState` call - this method itself never persists
-     * anything, so it's safe to call once per collection in a request without the write-batching hazard
-     * `EasSyncKeyUtils.persistDeviceSyncState`'s doc comment describes. */
-    async processCollection(ctx, collectionEl, getMailbox) {
+    effectiveWindowSize(requested) {
+        const limit = Math.min(this.windowSize, MAX_WINDOW_SIZE);
+        const value = Number(requested);
+        return requested !== undefined && Number.isInteger(value) && value > 0 ? Math.min(value, limit) : limit;
+    }
+    async processCollection(ctx, collectionEl, getMailbox, requestWindowSize, audit) {
         const requestedClass = childText(collectionEl, "Class");
         const folderUid = childText(collectionEl, "CollectionId");
         const clientSyncKey = childText(collectionEl, "SyncKey");
-        // Class is only required on a collection's first (SyncKey "0") request - see this class's own doc
-        // comment. A folder never previously synced has no remembered value to fall back to, so omitting Class
-        // there still (correctly) falls through to the "missing" branch below.
-        const collectionClass = requestedClass ?? (folderUid ? ctx.deviceSyncState.folderCollectionClasses?.[folderUid] : undefined);
-        if (!collectionClass || !folderUid) {
-            return { collectionElement: this.collectionResponse(collectionClass, folderUid, "4", clientSyncKey) };
+        // A folder the caller can't even read is reported identically to an unrecognized collection - never
+        // reveal whether a client-supplied CollectionId belonging to someone else's mailbox actually exists.
+        if (!folderUid || !(await this.aclUtils.hasPermission(ctx.user, folderUid, ACLAction.READ))) {
+            return this.collectionResponse(requestedClass, folderUid, "4", clientSyncKey);
+        }
+        const folder = await this.folderRepo.findOne(folderUid, { ignoreACL: true });
+        if (!folder) {
+            return this.collectionResponse(requestedClass, folderUid, "4", clientSyncKey);
+        }
+        const release = await EasCollectionLease.acquire(JSON.stringify([ctx.mailboxUid, ctx.deviceId, folderUid]), {
+            redisUrl: this.cacheConfig?.url,
+            ttlMs: LEASE_TTL_MS,
+            waitMs: this.leaseWaitMs,
+        });
+        if (!release) {
+            return this.collectionResponse(requestedClass, folderUid, STATUS_RETRY, clientSyncKey);
+        }
+        try {
+            return await this.processLocked(ctx, collectionEl, folder, getMailbox, requestWindowSize, audit);
         }
+        finally {
+            await release();
+        }
+    }
+    /** The rest of `processCollection`, run while holding the collection's lease. */
+    async processLocked(ctx, collectionEl, folder, getMailbox, requestWindowSize, audit) {
+        const folderUid = folder.uid;
+        const requestedClass = childText(collectionEl, "Class");
+        const clientSyncKey = childText(collectionEl, "SyncKey");
+        const stored = (await this.collectionStateRepo.find({ mailboxUid: ctx.mailboxUid, deviceId: ctx.deviceId, folderUid }, {
+            ignoreACL: true,
+            limit: 1,
+        }))[0];
+        const collectionClass = requestedClass ?? stored?.collectionClass ?? classForFolderType(folder.type);
         const repo = this.repos.get(collectionClass);
         const adapter = this.adapters.get(collectionClass);
-        if (!repo || !adapter) {
-            return { collectionElement: this.collectionResponse(collectionClass, folderUid, "4", clientSyncKey) };
+        const commandsEl = findChild(collectionEl, "Commands");
+        if (!repo || !adapter || (commandsEl?.children.length ?? 0) > MAX_SYNC_COMMANDS_PER_COLLECTION) {
+            return this.collectionResponse(collectionClass, folderUid, "4", clientSyncKey);
         }
-        // A folder the caller can't even read is reported identically to an unrecognized collection - never
-        // reveal whether a client-supplied CollectionId belonging to someone else's mailbox actually exists.
-        // See this class's own doc comment for why this check (and the matching ones in applyAdd/applyChange/
-        // applyDelete below) is required, not optional.
-        if (!(await this.aclUtils.hasPermission(ctx.user, folderUid, ACLAction.READ))) {
-            return { collectionElement: this.collectionResponse(collectionClass, folderUid, "4", clientSyncKey) };
-        }
-        const storedSyncKey = ctx.deviceSyncState.folderSyncKeys[folderUid];
-        const resolution = resolveSyncKey(clientSyncKey, storedSyncKey);
-        if (resolution.kind === "invalid") {
-            return { collectionElement: this.collectionResponse(collectionClass, folderUid, "3", undefined) };
-        }
-        if (resolution.kind === "initial") {
-            // Same epoch-not-"now" reasoning as FolderSyncCommand's own initial-sync branch: the client's next
-            // request (echoing this key) is its true first full sync of this folder and must see every
-            // existing item as an Add, not just ones modified after this handshake started.
-            const newKey = formatSyncKey({ generation: 1, watermark: new Date(0) });
-            return {
-                collectionElement: this.collectionResponse(collectionClass, folderUid, "1", newKey),
-                folderUid,
-                newSyncKey: newKey,
-                rememberedClass: requestedClass,
+        const optionsEl = findChild(collectionEl, "Options");
+        const requestedFilter = optionsEl ? childText(optionsEl, "FilterType") : undefined;
+        if (!clientSyncKey || clientSyncKey === "0") {
+            return await this.startCollection(ctx, stored, folderUid, collectionClass, requestedFilter);
+        }
+        let held;
+        try {
+            held = await loadHeldSet(stored, this.chunkStore);
+        }
+        catch (err) {
+            this.logger?.warn(`SyncCommand: failed to load sync state for folder ${folderUid}: ${err?.message}`);
+            return this.collectionResponse(collectionClass, folderUid, STATUS_SERVER_ERROR, clientSyncKey);
+        }
+        let working;
+        let retry;
+        if (stored && clientSyncKey === stored.syncKey) {
+            working = workingStateFromRow(stored, held.ids);
+        }
+        else if (stored?.previous && clientSyncKey === stored.previous.syncKey) {
+            working = workingStateFromRound(stored, stored.previous, held.ids);
+            retry = {
+                removedIds: new Set(stored.previous.removedIds),
+                clientIds: new Map(stored.previous.clientIds.map((entry) => [entry.clientId, entry.serverId])),
             };
         }
-        // Computed against the OLD watermark, BEFORE this round's own client-originated writes below are
-        // applied - this is what stops a client's own fresh Add/Change/Delete from being echoed straight back
-        // as a Commands/Add|Change|Delete in this SAME response.
-        const changes = await computeChanges(repo, "folderUid", folderUid, resolution.key.watermark, this.windowSize);
-        // Process the client's own Commands (if any) - after the read above, before computing the new SyncKey
-        // below (which must cover these writes too, or the NEXT round would re-report them as incoming
-        // server-side changes).
-        const requestCommands = findChild(collectionEl, "Commands");
-        const responseEntries = [];
-        let maxWriteWatermark;
-        const note = (date) => {
-            if (date && (!maxWriteWatermark || date > maxWriteWatermark))
-                maxWriteWatermark = date;
-        };
-        if (requestCommands) {
-            for (const el of findChildren(requestCommands, "Add")) {
-                const outcome = await this.applyAdd(ctx, adapter, repo, folderUid, el, getMailbox);
-                if (outcome.response)
-                    responseEntries.push(outcome.response);
-                note(outcome.writtenAt);
+        else {
+            return this.collectionResponse(collectionClass, folderUid, STATUS_INVALID_SYNC_KEY, undefined);
+        }
+        if (requestedFilter !== undefined && requestedFilter !== working.filterType) {
+            if (working.filterType === undefined && (working.serverIds.size === 0 || working.generation <= 1)) {
+                // Started without Options: adopt the first FilterType while the device still holds nothing it was
+                // selected without.
+                working.filterType = requestedFilter;
             }
-            for (const el of findChildren(requestCommands, "Change")) {
-                const outcome = await this.applyChange(ctx, adapter, repo, folderUid, el);
-                if (outcome.response)
-                    responseEntries.push(outcome.response);
-                note(outcome.writtenAt);
+            else {
+                // The window the device's items were selected with no longer matches - restart from SyncKey 0.
+                return this.collectionResponse(collectionClass, folderUid, STATUS_INVALID_SYNC_KEY, undefined);
             }
-            for (const el of findChildren(requestCommands, "Delete")) {
-                const outcome = await this.applyDelete(ctx, repo, folderUid, el);
-                if (outcome.response)
-                    responseEntries.push(outcome.response);
-                note(outcome.writtenAt);
+        }
+        const base = cloneWorkingState(working);
+        const round = {
+            ctx,
+            folder,
+            collectionClass,
+            adapter,
+            repo,
+            working,
+            retry,
+            clientIds: new Map(),
+            deletesAsMoves: childText(collectionEl, "DeletesAsMoves") !== "0",
+            getMailbox,
+            getFolderMailbox: folder.mailboxUid === ctx.mailboxUid ? getMailbox : this.mailboxLoader(folder.mailboxUid),
+            audit,
+        };
+        const responseEntries = [];
+        if (commandsEl) {
+            for (const el of commandsEl.children) {
+                const response = el.tag === "Add"
+                    ? await this.applyAdd(round, el)
+                    : el.tag === "Change"
+                        ? await this.applyChange(round, el)
+                        : el.tag === "Delete"
+                            ? await this.applyDelete(round, el)
+                            : undefined;
+                if (response) {
+                    responseEntries.push(response);
+                }
             }
         }
-        // Only ever extends the watermark forward past what `computeChanges` itself already determined - never
-        // jumps all the way to "now" unconditionally, which would silently skip over not-yet-enumerated
-        // pending changes whenever `changes.moreAvailable` is true.
-        const newWatermark = maxWriteWatermark && maxWriteWatermark > changes.newWatermark ? maxWriteWatermark : changes.newWatermark;
-        const newKey = formatSyncKey({ generation: resolution.key.generation + 1, watermark: newWatermark });
-        const totalChanges = changes.adds.length + changes.changes.length + changes.deletes.length;
-        if (totalChanges === 0 && responseEntries.length === 0) {
-            return {
-                collectionElement: this.collectionResponse(collectionClass, folderUid, "1", newKey),
+        const { commands, moreAvailable } = childText(collectionEl, "GetChanges") === "0"
+            ? { commands: [], moreAvailable: false }
+            : await enumerateCollection(working, {
+                repo,
                 folderUid,
-                newSyncKey: newKey,
-                rememberedClass: requestedClass,
-            };
+                folderMailboxUid: folder.mailboxUid,
+                windowSize: this.effectiveWindowSize(childText(collectionEl, "WindowSize") ?? requestWindowSize),
+                moveScanLimit: this.moveScanLimit,
+                reconcileLimit: this.reconcileLimit,
+                include: filterPredicate(collectionClass, working.filterType),
+            });
+        const newKey = formatSyncKey({ generation: working.generation + 1, watermark: working.cursor.date, uid: working.cursor.uid });
+        const saved = await this.saveState(stored, { loaded: held, ids: working.serverIds }, {
+            mailboxUid: ctx.mailboxUid,
+            deviceId: ctx.deviceId,
+            folderUid,
+            collectionClass,
+            syncKey: newKey,
+            cursorDate: working.cursor.date,
+            cursorUid: working.cursor.uid,
+            moveCursorDate: working.moveCursor.date,
+            moveCursorUid: working.moveCursor.uid,
+            echoes: Object.fromEntries(working.echoes),
+            ...(working.recent ? { recent: Object.fromEntries(working.recent) } : {}),
+            reconcileCursor: working.reconcileCursor,
+            filterType: working.filterType ?? null,
+            previous: roundRecord(clientSyncKey, base, working, round.clientIds),
+        });
+        if (!saved) {
+            return this.collectionResponse(collectionClass, folderUid, STATUS_INVALID_SYNC_KEY, undefined);
         }
-        const commandElements = [
-            ...(await Promise.all(changes.adds.map((item) => this.itemToCommandElement("Add", adapter, item)))),
-            ...(await Promise.all(changes.changes.map((item) => this.itemToCommandElement("Change", adapter, item)))),
-            ...changes.deletes.map((item) => element(WbxmlCodePage.AirSync, "Delete", [textElement(WbxmlCodePage.AirSync, "ServerId", item.uid)])),
-        ];
-        return {
-            collectionElement: this.collectionResponse(collectionClass, folderUid, "1", newKey, [
-                ...(changes.moreAvailable ? [element(WbxmlCodePage.AirSync, "MoreAvailable", [])] : []),
-                ...(commandElements.length > 0 ? [element(WbxmlCodePage.AirSync, "Commands", commandElements)] : []),
-                ...(responseEntries.length > 0 ? [element(WbxmlCodePage.AirSync, "Responses", responseEntries)] : []),
-            ]),
+        const upserts = commands.filter((c) => c.kind !== "Delete");
+        const applicationData = upserts.length === 0
+            ? []
+            : adapter.toApplicationDataBatch
+                ? await adapter.toApplicationDataBatch(upserts.map((c) => c.item))
+                : await Promise.all(upserts.map(async (c) => await adapter.toApplicationData(c.item)));
+        const commandElements = commands.map((c) => c.kind === "Delete"
+            ? element(WbxmlCodePage.AirSync, "Delete", [textElement(WbxmlCodePage.AirSync, "ServerId", c.uid)])
+            : element(WbxmlCodePage.AirSync, c.kind, [
+                textElement(WbxmlCodePage.AirSync, "ServerId", c.item.uid),
+                applicationData[upserts.indexOf(c)],
+            ]));
+        if (collectionClass === "Email" && upserts.length > 0) {
+            const messageUids = upserts.map((c) => c.item.uid);
+            await audit.record({
+                action: AuditAction.MESSAGE_CONTENT_ACCESSED,
+                mailboxUid: folder.mailboxUid,
+                targetType: "Folder",
+                targetUid: folderUid,
+                details: { operation: "Sync", count: messageUids.length, messageUids },
+            });
+        }
+        return this.collectionResponse(collectionClass, folderUid, "1", newKey, [
+            ...(moreAvailable ? [element(WbxmlCodePage.AirSync, "MoreAvailable", [])] : []),
+            ...(commandElements.length > 0 ? [element(WbxmlCodePage.AirSync, "Commands", commandElements)] : []),
+            ...(responseEntries.length > 0 ? [element(WbxmlCodePage.AirSync, "Responses", responseEntries)] : []),
+        ]);
+    }
+    /** `SyncKey 0`: (re)starts the collection with an empty item set. Per [MS-ASCMD] the response carries only the
+     * new key; the next round reports every item as an `Add`. */
+    async startCollection(ctx, stored, folderUid, collectionClass, filterType) {
+        const epoch = new Date(0);
+        const newKey = formatSyncKey({ generation: 1, watermark: epoch });
+        const saved = await this.saveState(stored, "restart", {
+            mailboxUid: ctx.mailboxUid,
+            deviceId: ctx.deviceId,
             folderUid,
-            newSyncKey: newKey,
-            rememberedClass: requestedClass,
-        };
+            collectionClass,
+            syncKey: newKey,
+            cursorDate: epoch,
+            cursorUid: "",
+            moveCursorDate: new Date(Date.now() - MOVE_CURSOR_SLACK_MS),
+            moveCursorUid: "",
+            echoes: {},
+            recent: {},
+            reconcileCursor: "",
+            // `null` (not `undefined`) so a restart without Options clears a FilterType recorded earlier on SQL too.
+            filterType: filterType ?? null,
+            previous: undefined,
+        });
+        if (!saved) {
+            return this.collectionResponse(collectionClass, folderUid, STATUS_SERVER_ERROR, undefined);
+        }
+        return this.collectionResponse(collectionClass, folderUid, "1", newKey);
     }
-    async itemToCommandElement(kind, adapter, item) {
-        return element(WbxmlCodePage.AirSync, kind, [
-            textElement(WbxmlCodePage.AirSync, "ServerId", item.uid),
-            await adapter.toApplicationData(item),
-        ]);
+    /**
+     * Writes the held set (`held.ids`, given the set `held.loaded` the round started from) and then creates or
+     * updates the collection's state row. Returns `false` - after logging - when anything failed (including losing a
+     * race for the row): the caller must then not hand out the new key. A `"restart"` empties the held set.
+     *
+     * **Chunk writes can't be atomic with the state row**, so before any chunk row is touched the state row is first
+     * marked `chunked` with both its `SyncKey` and its previous round's key blanked (`invalidateBeforeChunkWrite()`).
+     * If anything after that fails - including the final state write, and even when the device never sees this round's
+     * Status 3 - no key matches the half-written chunks any more: the device's next `Sync` gets Status 3 and restarts
+     * with `SyncKey 0`, which always removes every chunk row of the collection (whether or not the row says `chunked`,
+     * so rows orphaned before this rule existed are cleared too). A collection converting from inline to chunked also
+     * clears leftover chunk rows first, so an orphan can never collide with the unique `chunkIndex`.
+     */
+    async saveState(stored, held, values) {
+        try {
+            let heldValues;
+            let current = stored;
+            if (held === "restart") {
+                await clearHeldSet(values, this.chunkStore);
+                heldValues = { serverIds: [], chunked: false };
+            }
+            else {
+                const wasChunked = !!stored?.chunked;
+                if (stored && (wasChunked || held.ids.size > INLINE_HELD_LIMIT)) {
+                    current = await this.invalidateBeforeChunkWrite(stored);
+                    if (!wasChunked) {
+                        await clearHeldSet(values, this.chunkStore);
+                    }
+                }
+                heldValues = await saveHeldSet(values, held.loaded, held.ids, wasChunked, this.chunkStore);
+            }
+            const row = { ...values, ...heldValues };
+            if (current) {
+                await this.collectionStateRepo.update({ ...row, uid: current.uid, version: current.version }, asEntity(this.collectionStateRepo, current), { ignoreACL: true, skipPush: true });
+            }
+            else {
+                await this.collectionStateRepo.create(new this.collectionStateClass(row), { ignoreACL: true, skipPush: true });
+            }
+            return true;
+        }
+        catch (err) {
+            this.logger?.warn(`SyncCommand: failed to save sync state for folder ${values.folderUid}: ${err?.message}`);
+            return false;
+        }
+    }
+    /** Marks `stored` chunked with no acceptable `SyncKey` (current or previous) before its chunk rows are written - see
+     * `saveState()`. Returns the updated row, whose version the final state write must carry. */
+    async invalidateBeforeChunkWrite(stored) {
+        return await this.collectionStateRepo.update({
+            uid: stored.uid,
+            version: stored.version,
+            syncKey: "",
+            ...(stored.previous ? { previous: { ...stored.previous, syncKey: "" } } : {}),
+            serverIds: [],
+            chunked: true,
+        }, asEntity(this.collectionStateRepo, stored), { ignoreACL: true, skipPush: true });
     }
-    /** One client-originated command's outcome: `response` is a `Responses/{Add,Change,Delete}` entry to
-     * include (per MS-ASCMD, always present for `Add`, only present on failure for `Change`/`Delete`);
-     * `writtenAt` is the resulting `dateModified` of whatever was actually written, used to advance the
-     * persisted watermark past this round's own writes (see `handle()`'s own comment on why). */
     addResponseElement(clientId, serverId, status) {
         return element(WbxmlCodePage.AirSync, "Add", [
             ...(clientId ? [textElement(WbxmlCodePage.AirSync, "ClientId", clientId)] : []),
@@ -280,105 +457,153 @@ export class SyncCommand {
             textElement(WbxmlCodePage.AirSync, "Status", status),
         ]);
     }
-    async applyAdd(ctx, adapter, repo, folderUid, el, getMailbox) {
+    /** Remembers the `dateModified` the device's own write left on `item`, so the write isn't echoed back. */
+    noteWrite(round, item) {
+        round.working.serverIds.add(item.uid);
+        if (item.dateModified !== undefined) {
+            round.working.echoes.set(item.uid, new Date(item.dateModified).toISOString());
+        }
+    }
+    async applyAdd(round, el) {
+        const { ctx, adapter, repo, folder } = round;
         const clientId = childText(el, "ClientId");
+        const replayed = clientId ? round.retry?.clientIds.get(clientId) : undefined;
+        if (clientId && replayed) {
+            // The first attempt already created the item: answer with it, and treat its current state as the device's own
+            // write so the replayed round doesn't send it back as a Change.
+            const item = await repo.findOne(replayed, { ignoreACL: true });
+            if (item) {
+                this.noteWrite(round, item);
+            }
+            round.clientIds.set(clientId, replayed);
+            return this.addResponseElement(clientId, replayed, "1");
+        }
         const appData = findChild(el, "ApplicationData");
-        // [MS-ASCMD] "Add (Sync)": "The Add element cannot be used to add any non-draft email items from the
-        // client to the server" - this pragmatic subset extends that same Status 6 to every collection whose
-        // adapter has no fromApplicationData at all, rather than special-casing "Email" by name.
         if (!adapter.fromApplicationData || !appData) {
-            return { response: this.addResponseElement(clientId, undefined, "6") };
+            return this.addResponseElement(clientId, undefined, "6");
+        }
+        // [MS-ASCMD] "Add (Sync)": a client can only add *draft* email.
+        if (round.collectionClass === "Email" && folder.type !== FolderType.DRAFTS) {
+            return this.addResponseElement(clientId, undefined, "6");
         }
-        // The top-level per-collection READ check (processCollection) only proves the caller can see this
-        // folder - a shared/read-only folder still needs its own CREATE check before anything is written into it.
-        if (!(await this.aclUtils.hasPermission(ctx.user, folderUid, ACLAction.CREATE))) {
-            return { response: this.addResponseElement(clientId, undefined, "6") };
+        if (!(await this.aclUtils.hasPermission(ctx.user, folder.uid, ACLAction.CREATE))) {
+            return this.addResponseElement(clientId, undefined, "6");
         }
         try {
-            const defaults = adapter.newEntityDefaults ? adapter.newEntityDefaults(await getMailbox()) : {};
-            const partial = await adapter.fromApplicationData(appData);
-            const created = await repo.create({ ...defaults, ...partial, mailboxUid: ctx.mailboxUid, folderUid }, { ignoreACL: true });
-            return {
-                response: this.addResponseElement(clientId, created.uid, "1"),
-                writtenAt: created.dateModified,
-            };
+            const mailbox = await round.getMailbox();
+            const defaults = adapter.newEntityDefaults ? adapter.newEntityDefaults(mailbox) : {};
+            const partial = await adapter.fromApplicationData(appData, undefined, mailbox);
+            const created = await repo.create({ ...defaults, ...partial, mailboxUid: folder.mailboxUid, folderUid: folder.uid }, { ignoreACL: true });
+            this.noteWrite(round, created);
+            if (clientId) {
+                round.clientIds.set(clientId, created.uid);
+            }
+            return this.addResponseElement(clientId, created.uid, "1");
         }
         catch {
-            // A malformed/invalid item (bad enum value, missing required field like Calendar's OrganizerEmail,
-            // ...) - Status 6 is [MS-ASCMD]'s own designated code for exactly this ("client/server conversion
-            // error... client has sent a malformed or invalid item").
-            return { response: this.addResponseElement(clientId, undefined, "6") };
+            // Status 6: "the client has sent a malformed or invalid item".
+            return this.addResponseElement(clientId, undefined, "6");
         }
     }
-    async applyChange(ctx, adapter, repo, folderUid, el) {
+    async applyChange(round, el) {
+        const { ctx, adapter, repo, folder } = round;
         const serverId = childText(el, "ServerId");
         if (!serverId) {
-            return {};
+            return undefined;
         }
         if (!adapter.fromApplicationData) {
-            return { response: this.statusResponseElement("Change", serverId, "6") };
+            return this.statusResponseElement("Change", serverId, "6");
         }
         const existing = await repo.findOne(serverId, { ignoreACL: true });
-        // A ServerId that resolves to an item outside this (already ACL-verified-for-READ) collection is
-        // reported identically to "doesn't exist" - never reveal that it's real, just filed elsewhere (a
-        // different folder, or another mailbox's entirely). See this class's own doc comment.
-        if (!existing || existing.folderUid !== folderUid) {
-            return { response: this.statusResponseElement("Change", serverId, "8") };
+        // An item outside this (READ-checked) collection is reported identically to "doesn't exist".
+        if (!existing || existing.folderUid !== folder.uid) {
+            return this.statusResponseElement("Change", serverId, "8");
         }
-        if (!(await this.aclUtils.hasPermission(ctx.user, folderUid, ACLAction.UPDATE))) {
-            return { response: this.statusResponseElement("Change", serverId, "6") };
+        if (!(await this.aclUtils.hasPermission(ctx.user, folder.uid, ACLAction.UPDATE))) {
+            return this.statusResponseElement("Change", serverId, "6");
         }
         const appData = findChild(el, "ApplicationData");
         if (!appData) {
-            return { response: this.statusResponseElement("Change", serverId, "6") };
+            return this.statusResponseElement("Change", serverId, "6");
         }
         try {
-            const partial = await adapter.fromApplicationData(appData, existing);
-            const updated = await repo.update({ uid: existing.uid, version: existing.version, ...partial }, existing, { ignoreACL: true });
-            // Success is silent per [MS-ASCMD]'s own "the client only receives responses for ... failed
-            // changes" rule - no response entry.
-            return { writtenAt: updated.dateModified };
+            const partial = await adapter.fromApplicationData(appData, existing, await round.getFolderMailbox());
+            const updated = await repo.update({ uid: existing.uid, version: existing.version, ...partial }, asEntity(repo, existing), { ignoreACL: true });
+            this.noteWrite(round, updated);
+            return undefined;
         }
         catch (err) {
             if (err instanceof ApiError && err.code === ApiErrors.INVALID_OBJECT_VERSION) {
-                return { response: this.statusResponseElement("Change", serverId, "7") };
+                return this.statusResponseElement("Change", serverId, "7");
             }
-            return { response: this.statusResponseElement("Change", serverId, "6") };
+            return this.statusResponseElement("Change", serverId, "6");
         }
     }
-    async applyDelete(ctx, repo, folderUid, el) {
+    async applyDelete(round, el) {
+        const { ctx, adapter, repo, folder } = round;
         const serverId = childText(el, "ServerId");
         if (!serverId) {
-            return {};
+            return undefined;
         }
         const existing = await repo.findOne(serverId, { ignoreACL: true });
-        // Same "treat as not found" rule applyChange uses - see its own comment.
-        if (!existing || existing.folderUid !== folderUid) {
-            return { response: this.statusResponseElement("Delete", serverId, "8") };
+        if (!existing || existing.folderUid !== folder.uid) {
+            // The retried round already deleted (or moved) this item - the device's retry is already satisfied.
+            if (round.retry?.removedIds.has(serverId)) {
+                round.working.serverIds.delete(serverId);
+                return undefined;
+            }
+            return this.statusResponseElement("Delete", serverId, "8");
+        }
+        if (!(await this.aclUtils.hasPermission(ctx.user, folder.uid, ACLAction.DELETE))) {
+            return this.statusResponseElement("Delete", serverId, "6");
         }
-        if (!(await this.aclUtils.hasPermission(ctx.user, folderUid, ACLAction.DELETE))) {
-            return { response: this.statusResponseElement("Delete", serverId, "6") };
+        // Like restapi's delete (409), never while a send of the message is in flight - a moved or deleted message could
+        // miss its relay marker and be sent again.
+        if (hasLiveSendLease(existing)) {
+            return this.statusResponseElement("Delete", serverId, "6");
         }
         try {
-            await repo.delete(existing.uid, { ignoreACL: true });
-            // Re-read the now-soft-deleted row's own `dateModified` (`RecoverableRepoUtils.delete()` stamps it
-            // as part of the delete itself) rather than approximating with a fresh `new Date()` here. A plain
-            // `new Date()` captured after the write resolves is always >= that real timestamp (the delete's own
-            // internal write already completed by the time this line runs) - close enough for THIS row, but
-            // `newWatermark` is folder-wide: if it's inflated even slightly past this row's true write time, it
-            // can also run past a genuinely concurrent, unrelated write to a DIFFERENT message in the same
-            // folder that `computeChanges` already missed (it snapshotted before this Delete ran), permanently
-            // skipping that other change instead of picking it up next round. Falls back to `new Date()` only
-            // if the re-read is unexpectedly empty, which real code paths never hit.
-            const deleted = await repo.findOne(existing.uid, { ignoreACL: true, includeDeleted: true });
-            return { writtenAt: deleted?.dateModified ?? new Date() };
+            if (round.collectionClass === "Email" && round.deletesAsMoves && folder.type !== FolderType.DELETED_ITEMS) {
+                const deletedItems = await findOrCreateWellKnownFolder(this.folderRepo, this.folderClass, folder.mailboxUid, FolderType.DELETED_ITEMS, ctx.user);
+                // A move out of Outbox cancels the scheduled send (or is refused once the message was relayed).
+                const plan = planMessageMove(existing, folder.type, FolderType.DELETED_ITEMS);
+                if (!plan.allowed) {
+                    return this.statusResponseElement("Delete", serverId, "6");
+                }
+                await repo.update({ uid: existing.uid, version: existing.version, folderUid: deletedItems.uid, ...plan.patch }, asEntity(repo, existing), {
+                    ignoreACL: true,
+                    user: ctx.user,
+                });
+            }
+            else {
+                const stamp = adapter.beforeDelete ? adapter.beforeDelete(existing, await round.getFolderMailbox()) : undefined;
+                if (stamp) {
+                    await repo.update({ uid: existing.uid, version: existing.version, ...stamp }, asEntity(repo, existing), { ignoreACL: true });
+                }
+                await repo.delete(existing.uid, { ignoreACL: true });
+            }
+            if (round.collectionClass === "Email") {
+                await round.audit.record({
+                    action: AuditAction.MESSAGE_DELETE,
+                    mailboxUid: existing.mailboxUid,
+                    targetType: "Message",
+                    targetUid: existing.uid,
+                    details: {
+                        subject: existing.subject,
+                        folderUid: existing.folderUid,
+                        movedToDeletedItems: round.deletesAsMoves && folder.type !== FolderType.DELETED_ITEMS,
+                    },
+                });
+            }
+            round.working.serverIds.delete(serverId);
+            round.working.echoes.delete(serverId);
+            return undefined;
         }
         catch {
-            return { response: this.statusResponseElement("Delete", serverId, "6") };
+            return this.statusResponseElement("Delete", serverId, "6");
         }
     }
-    /** Builds one `<Collection>` response element - `handle()` collects one of these per request `<Collection>`
-     * and wraps the whole set in a single `<Sync><Collections>`. */
+    /** Builds one `<Collection>` response element. */
     collectionResponse(collectionClass, folderUid, status, syncKey, extra = []) {
         return element(WbxmlCodePage.AirSync, "Collection", [
             ...(collectionClass ? [textElement(WbxmlCodePage.AirSync, "Class", collectionClass)] : []),
@@ -393,10 +618,22 @@ __decorate([
     Config("mail:eas:sync_window_size", DEFAULT_WINDOW_SIZE),
     __metadata("design:type", Number)
 ], SyncCommand.prototype, "windowSize", void 0);
+__decorate([
+    Config("datastores:cache", null),
+    __metadata("design:type", Object)
+], SyncCommand.prototype, "cacheConfig", void 0);
+__decorate([
+    Config(),
+    __metadata("design:type", Object)
+], SyncCommand.prototype, "config", void 0);
 __decorate([
     Inject(ACLUtils),
     __metadata("design:type", ACLUtils)
 ], SyncCommand.prototype, "aclUtils", void 0);
+__decorate([
+    Logger,
+    __metadata("design:type", Object)
+], SyncCommand.prototype, "logger", void 0);
 __decorate([
     Init,
     __metadata("design:type", Function),