@rapidmx/activesync 1.0.0-beta.0

package/dist/lib/commands/SendMailCommand.js

@@ -0,0 +1,18 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { ComposeMailCommand } from "./ComposeMailCommand.js";
+/**
+ * Handles EAS `SendMail`: relays a freshly composed message with no referenced original - see
+ * `ComposeMailCommand`'s own doc comment for the full shared implementation.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export class SendMailCommand extends ComposeMailCommand {
+    constructor() {
+        super(...arguments);
+        this.command = "SendMail";
+    }
+}
+//# sourceMappingURL=SendMailCommand.js.map

package/dist/lib/commands/SendMailCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SendMailCommand.js","sourceRoot":"","sources":["../../../src/commands/SendMailCommand.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,mEAAmE;AACnE,mCAAmC;AACnC,+EAA+E;AAC/E,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,OAAgB,eAAgB,SAAQ,kBAAkB;IAAhE;;QACoB,YAAO,GAAG,UAAU,CAAC;IACzC,CAAC;CAAA"}

package/dist/lib/commands/SettingsCommand.js

@@ -0,0 +1,138 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { ApiError, ObjectDecorators } from "@rapidrest/core";
+import { ApiErrorMessages, ApiErrors, RepoUtils } from "@rapidrest/service-core";
+import { WbxmlCodePage } from "../codec/WbxmlCodePages.js";
+import { childText, element, findChild, textElement } from "../codec/WbxmlElement.js";
+const { Init } = ObjectDecorators;
+/**
+ * Handles EAS `Settings`: the first-run/general-purpose device<->server settings exchange. This pragmatic
+ * subset supports the sub-elements every real client actually depends on:
+ *
+ * - `UserInformation`/`Get`: returns the mailbox's `primarySmtpAddress`/`aliasAddresses` as `EmailAddresses`.
+ * - `DeviceInformation`/`Set`: acknowledged with `Status 1` but not persisted anywhere - `DeviceSyncState` has
+ * no fields for a device's model/IMEI/OS/friendly name, and nothing else in this library currently consumes
+ * them. A real client only requires the acknowledgement to proceed past first-run setup, not that the values
+ * are retrievable later.
+ * - `Oof`/`Get` and `Oof`/`Set`: reads/writes `Mailbox.oofEnabled`/`oofMessage`/`oofStartTime`/`oofEndTime`.
+ * `StartTime`/`EndTime` use MS-ASDTYPE's plain `dateTime` type (`Date.prototype.toISOString()`), not Compact
+ * DateTime - confirmed against MS-ASSETTINGS directly, unlike `Calendar`/`Tasks`' timestamp fields (see
+ * `CompactDateTime.ts`'s own doc comment on that exact distinction). A single combined reply message is stored
+ * rather than the spec's three audience-specific `OofMessage` variants (internal/external-known/
+ * external-unknown) - matches this codebase's existing "one thing, not three" simplification precedent (e.g.
+ * `ContactsSyncAdapter`'s single-slot phone/email handling).
+ * - `RightsManagementInformation` is not implemented - deferred, matching this library's "pragmatic subset"
+ * precedent elsewhere (e.g. `ComposeMailCommand`'s own documented gaps).
+ *
+ * `mailboxClass` is supplied by the Mongo/SQL concrete subclasses.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export class SettingsCommand {
+    constructor() {
+        this.command = "Settings";
+    }
+    async init() {
+        this.mailboxRepo = await this._objectFactory.newInstance(RepoUtils, {
+            name: this.mailboxClass.name,
+            args: [this.mailboxClass],
+        });
+    }
+    async handle(ctx) {
+        if (!this.mailboxRepo) {
+            throw new ApiError(ApiErrors.INTERNAL_ERROR, 500, ApiErrorMessages.INTERNAL_ERROR);
+        }
+        const children = [textElement(WbxmlCodePage.Settings, "Status", "1")];
+        if (ctx.request && findChild(ctx.request, "DeviceInformation")) {
+            children.push(element(WbxmlCodePage.Settings, "DeviceInformation", [textElement(WbxmlCodePage.Settings, "Status", "1")]));
+        }
+        if (ctx.request && findChild(ctx.request, "UserInformation")) {
+            const mailbox = await this.mailboxRepo.findOne(ctx.mailboxUid, { ignoreACL: true });
+            if (!mailbox) {
+                throw new ApiError(ApiErrors.NOT_FOUND, 404, ApiErrorMessages.NOT_FOUND);
+            }
+            children.push(element(WbxmlCodePage.Settings, "UserInformation", [
+                textElement(WbxmlCodePage.Settings, "Status", "1"),
+                element(WbxmlCodePage.Settings, "EmailAddresses", [
+                    textElement(WbxmlCodePage.Settings, "SmtpAddress", mailbox.primarySmtpAddress),
+                    ...mailbox.aliasAddresses.map((address) => textElement(WbxmlCodePage.Settings, "SmtpAddress", address)),
+                ]),
+            ]));
+        }
+        const oofEl = ctx.request ? findChild(ctx.request, "Oof") : undefined;
+        if (oofEl) {
+            const mailbox = await this.mailboxRepo.findOne(ctx.mailboxUid, { ignoreACL: true });
+            if (!mailbox) {
+                throw new ApiError(ApiErrors.NOT_FOUND, 404, ApiErrorMessages.NOT_FOUND);
+            }
+            const setEl = findChild(oofEl, "Set");
+            children.push(setEl ? await this.setOof(ctx, mailbox, setEl) : this.getOof(mailbox));
+        }
+        return element(WbxmlCodePage.Settings, "Settings", children);
+    }
+    /** `OofState`: `0`=disabled, `1`=enabled indefinitely, `2`=time-based (only while now is within
+     * `StartTime`/`EndTime`). */
+    getOof(mailbox) {
+        const timed = mailbox.oofEnabled && !!mailbox.oofStartTime && !!mailbox.oofEndTime;
+        return element(WbxmlCodePage.Settings, "Oof", [
+            textElement(WbxmlCodePage.Settings, "Status", "1"),
+            element(WbxmlCodePage.Settings, "Get", [
+                textElement(WbxmlCodePage.Settings, "OofState", mailbox.oofEnabled ? (timed ? "2" : "1") : "0"),
+                ...(timed
+                    ? [
+                        textElement(WbxmlCodePage.Settings, "StartTime", mailbox.oofStartTime.toISOString()),
+                        textElement(WbxmlCodePage.Settings, "EndTime", mailbox.oofEndTime.toISOString()),
+                    ]
+                    : []),
+                element(WbxmlCodePage.Settings, "OofMessage", [
+                    element(WbxmlCodePage.Settings, "AppliesToInternal", []),
+                    textElement(WbxmlCodePage.Settings, "Enabled", mailbox.oofEnabled ? "1" : "0"),
+                    textElement(WbxmlCodePage.Settings, "ReplyMessage", mailbox.oofMessage),
+                    textElement(WbxmlCodePage.Settings, "BodyType", "Text"),
+                ]),
+            ]),
+        ]);
+    }
+    async setOof(ctx, mailbox, setEl) {
+        const oofState = childText(setEl, "OofState") ?? "0";
+        const oofMessageEl = findChild(setEl, "OofMessage");
+        const replyMessage = oofMessageEl ? (childText(oofMessageEl, "ReplyMessage") ?? "") : "";
+        const startTime = childText(setEl, "StartTime");
+        const endTime = childText(setEl, "EndTime");
+        const timed = oofState === "2" && startTime !== undefined && endTime !== undefined;
+        // `null`, not `undefined`, to clear a previously-set window when switching away from time-based Oof:
+        // TypeORM's `UpdateQueryBuilder` silently drops any `undefined`-valued key from the generated SQL `SET`
+        // clause (confirmed by reading its source), so `undefined` here would leave a stale StartTime/EndTime
+        // in place on the SQL backend while correctly clearing it on Mongo - `null` clears it on both.
+        await this.mailboxRepo.update({
+            uid: mailbox.uid,
+            version: mailbox.version,
+            oofEnabled: oofState !== "0",
+            oofMessage: replyMessage,
+            oofStartTime: timed ? new Date(startTime) : null,
+            oofEndTime: timed ? new Date(endTime) : null,
+        }, mailbox, { ignoreACL: true, user: ctx.user });
+        return element(WbxmlCodePage.Settings, "Oof", [
+            textElement(WbxmlCodePage.Settings, "Status", "1"),
+            element(WbxmlCodePage.Settings, "Set", [textElement(WbxmlCodePage.Settings, "Status", "1")]),
+        ]);
+    }
+}
+__decorate([
+    Init,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SettingsCommand.prototype, "init", null);
+//# sourceMappingURL=SettingsCommand.js.map

package/dist/lib/commands/SettingsCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SettingsCommand.js","sourceRoot":"","sources":["../../../src/commands/SettingsCommand.ts"],"names":[],"mappings":"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"}

package/dist/lib/commands/SmartForwardCommand.js

@@ -0,0 +1,22 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { ComposeMailCommand } from "./ComposeMailCommand.js";
+/**
+ * Handles EAS `SmartForward`: relays a freshly composed message threaded to (and referencing) the original via
+ * `<Source>`, then flips the original's `Forwarded` flag - see `ComposeMailCommand`'s own doc comment for the
+ * full shared implementation and this pragmatic subset's scope.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export class SmartForwardCommand extends ComposeMailCommand {
+    constructor() {
+        super(...arguments);
+        this.command = "SmartForward";
+    }
+    async markOriginal(ctx, original) {
+        await this.messageRepo.update({ uid: original.uid, version: original.version, flags: { ...original.flags, forwarded: true } }, original, { ignoreACL: true, user: ctx.user });
+    }
+}
+//# sourceMappingURL=SmartForwardCommand.js.map

package/dist/lib/commands/SmartForwardCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SmartForwardCommand.js","sourceRoot":"","sources":["../../../src/commands/SmartForwardCommand.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,mEAAmE;AACnE,mCAAmC;AACnC,+EAA+E;AAC/E,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAI7D;;;;;;GAMG;AACH,MAAM,OAAgB,mBAAoB,SAAQ,kBAAkB;IAApE;;QACoB,YAAO,GAAG,cAAc,CAAC;IAS7C,CAAC;IAPsB,KAAK,CAAC,YAAY,CAAC,GAAsB,EAAE,QAAoD;QAC9G,MAAM,IAAI,CAAC,WAAY,CAAC,MAAM,CAC1B,EAAE,GAAG,EAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,GAAG,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,EAAS,EACtG,QAAQ,EACR,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,CACtC,CAAC;IACN,CAAC;CACJ"}

package/dist/lib/commands/SmartReplyCommand.js

@@ -0,0 +1,22 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { ComposeMailCommand } from "./ComposeMailCommand.js";
+/**
+ * Handles EAS `SmartReply`: relays a freshly composed message threaded to (and referencing) the original via
+ * `<Source>`, then flips the original's `Answered` flag - see `ComposeMailCommand`'s own doc comment for the
+ * full shared implementation and this pragmatic subset's scope.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export class SmartReplyCommand extends ComposeMailCommand {
+    constructor() {
+        super(...arguments);
+        this.command = "SmartReply";
+    }
+    async markOriginal(ctx, original) {
+        await this.messageRepo.update({ uid: original.uid, version: original.version, flags: { ...original.flags, answered: true } }, original, { ignoreACL: true, user: ctx.user });
+    }
+}
+//# sourceMappingURL=SmartReplyCommand.js.map

package/dist/lib/commands/SmartReplyCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SmartReplyCommand.js","sourceRoot":"","sources":["../../../src/commands/SmartReplyCommand.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,mEAAmE;AACnE,mCAAmC;AACnC,+EAA+E;AAC/E,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAI7D;;;;;;GAMG;AACH,MAAM,OAAgB,iBAAkB,SAAQ,kBAAkB;IAAlE;;QACoB,YAAO,GAAG,YAAY,CAAC;IAS3C,CAAC;IAPsB,KAAK,CAAC,YAAY,CAAC,GAAsB,EAAE,QAAoD;QAC9G,MAAM,IAAI,CAAC,WAAY,CAAC,MAAM,CAC1B,EAAE,GAAG,EAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,GAAG,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAS,EACrG,QAAQ,EACR,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,CACtC,CAAC;IACN,CAAC;CACJ"}

package/dist/lib/commands/SyncCommand.js

@@ -0,0 +1,406 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { ApiError, ObjectDecorators } from "@rapidrest/core";
+import { ACLAction, ACLUtils, ApiErrorMessages, ApiErrors, RepoUtils, } from "@rapidrest/service-core";
+import { 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). */
+const DEFAULT_WINDOW_SIZE = 100;
+/**
+ * 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).
+ *
+ * **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.
+ *
+ * **`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).
+ *
+ * **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.
+ *
+ * **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).
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export class SyncCommand {
+    constructor() {
+        this.command = "Sync";
+        this.windowSize = DEFAULT_WINDOW_SIZE;
+        this.repos = new Map();
+        this.adapters = new Map();
+    }
+    async init() {
+        this.mailboxRepo = await this._objectFactory.newInstance(RepoUtils, {
+            name: this.mailboxClass.name,
+            args: [this.mailboxClass],
+        });
+        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.
+            this.repos.set(collectionClass, await this._objectFactory.newInstance(RecoverableRepoUtils, {
+                name: binding.entityClass.name,
+                args: [binding.entityClass],
+            }));
+            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) {
+        let cached;
+        return async () => {
+            if (!cached) {
+                cached = await this.mailboxRepo.findOne(ctx.mailboxUid, { ignoreACL: true });
+                if (!cached) {
+                    throw new ApiError(ApiErrors.NOT_FOUND, 404, "The caller's own mailbox no longer exists.");
+                }
+            }
+            return cached;
+        };
+    }
+    async handle(ctx) {
+        if (!this.aclUtils) {
+            throw new ApiError(ApiErrors.INTERNAL_ERROR, 500, ApiErrorMessages.INTERNAL_ERROR);
+        }
+        const collections = ctx.request ? findChild(ctx.request, "Collections") : undefined;
+        const collectionEls = collections ? findChildren(collections, "Collection") : [];
+        if (collectionEls.length === 0) {
+            return element(WbxmlCodePage.AirSync, "Sync", [textElement(WbxmlCodePage.AirSync, "Status", "3")]);
+        }
+        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,
+                };
+            }
+        }
+        if (folderSyncKeys || folderCollectionClasses) {
+            await persistDeviceSyncState(ctx.deviceSyncState, ctx.deviceSyncStateRepo, {
+                ...(folderSyncKeys ? { folderSyncKeys } : {}),
+                ...(folderCollectionClasses ? { folderCollectionClasses } : {}),
+            });
+        }
+        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) {
+        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) };
+        }
+        const repo = this.repos.get(collectionClass);
+        const adapter = this.adapters.get(collectionClass);
+        if (!repo || !adapter) {
+            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.
+        // 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,
+            };
+        }
+        // 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);
+            }
+            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);
+            }
+            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);
+            }
+        }
+        // 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),
+                folderUid,
+                newSyncKey: newKey,
+                rememberedClass: requestedClass,
+            };
+        }
+        const commandElements = [
+            ...changes.adds.map((item) => this.itemToCommandElement("Add", adapter, item)),
+            ...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)] : []),
+            ]),
+            folderUid,
+            newSyncKey: newKey,
+            rememberedClass: requestedClass,
+        };
+    }
+    itemToCommandElement(kind, adapter, item) {
+        return element(WbxmlCodePage.AirSync, kind, [
+            textElement(WbxmlCodePage.AirSync, "ServerId", item.uid),
+            adapter.toApplicationData(item),
+        ]);
+    }
+    /** 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)] : []),
+            ...(serverId ? [textElement(WbxmlCodePage.AirSync, "ServerId", serverId)] : []),
+            textElement(WbxmlCodePage.AirSync, "Status", status),
+        ]);
+    }
+    statusResponseElement(kind, serverId, status) {
+        return element(WbxmlCodePage.AirSync, kind, [
+            textElement(WbxmlCodePage.AirSync, "ServerId", serverId),
+            textElement(WbxmlCodePage.AirSync, "Status", status),
+        ]);
+    }
+    async applyAdd(ctx, adapter, repo, folderUid, el, getMailbox) {
+        const clientId = childText(el, "ClientId");
+        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") };
+        }
+        // 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") };
+        }
+        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,
+            };
+        }
+        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") };
+        }
+    }
+    async applyChange(ctx, adapter, repo, folderUid, el) {
+        const serverId = childText(el, "ServerId");
+        if (!serverId) {
+            return {};
+        }
+        if (!adapter.fromApplicationData) {
+            return { response: 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") };
+        }
+        if (!(await this.aclUtils.hasPermission(ctx.user, folderUid, ACLAction.UPDATE))) {
+            return { response: this.statusResponseElement("Change", serverId, "6") };
+        }
+        const appData = findChild(el, "ApplicationData");
+        if (!appData) {
+            return { response: 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 };
+        }
+        catch (err) {
+            if (err instanceof ApiError && err.code === ApiErrors.INVALID_OBJECT_VERSION) {
+                return { response: this.statusResponseElement("Change", serverId, "7") };
+            }
+            return { response: this.statusResponseElement("Change", serverId, "6") };
+        }
+    }
+    async applyDelete(ctx, repo, folderUid, el) {
+        const serverId = childText(el, "ServerId");
+        if (!serverId) {
+            return {};
+        }
+        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 (!(await this.aclUtils.hasPermission(ctx.user, folderUid, ACLAction.DELETE))) {
+            return { response: 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() };
+        }
+        catch {
+            return { response: 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>`. */
+    collectionResponse(collectionClass, folderUid, status, syncKey, extra = []) {
+        return element(WbxmlCodePage.AirSync, "Collection", [
+            ...(collectionClass ? [textElement(WbxmlCodePage.AirSync, "Class", collectionClass)] : []),
+            ...(syncKey ? [textElement(WbxmlCodePage.AirSync, "SyncKey", syncKey)] : []),
+            ...(folderUid ? [textElement(WbxmlCodePage.AirSync, "CollectionId", folderUid)] : []),
+            textElement(WbxmlCodePage.AirSync, "Status", status),
+            ...extra,
+        ]);
+    }
+}
+__decorate([
+    Config("mail:eas:sync_window_size", DEFAULT_WINDOW_SIZE),
+    __metadata("design:type", Number)
+], SyncCommand.prototype, "windowSize", void 0);
+__decorate([
+    Inject(ACLUtils),
+    __metadata("design:type", ACLUtils)
+], SyncCommand.prototype, "aclUtils", void 0);
+__decorate([
+    Init,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SyncCommand.prototype, "init", null);
+//# sourceMappingURL=SyncCommand.js.map