@push.rocks/smartjmap 2.0.0 → 2.1.0

package/ts/classes.jmapserver.ts

@@ -1,13 +1,14 @@
-import * as plugins from './smartjmap.plugins.js';
+import * as plugins from "./smartjmap.plugins.js";
 import {
+  type IJmapEmailBodyValue,
   JMAP_CORE_CAPABILITY,
   JMAP_MAIL_CAPABILITY,
   JMAP_SUBMISSION_CAPABILITY,
-  type IJmapEmailBodyValue,
   type TJmapMethodResponse,
-} from './classes.jmapclient.js';
+} from "./classes.jmapclient.js";
 import {
   type IJmapAccountInfo,
+  type IJmapBlobUploadStream,
   type IJmapEmailCreate,
   type IJmapEmailFilter,
   type IJmapEmailRecord,
@@ -17,8 +18,15 @@ import {
   type IJmapMailBackend,
   type IJmapSetError,
   type TJmapPrincipal,
-} from './interfaces.backend.js';
-import { MemoryMailBackend } from './classes.memorymailbackend.js';
+} from "./interfaces.backend.js";
+import { MemoryMailBackend } from "./classes.memorymailbackend.js";
+
+/**
+ * Semantic capability marker for the bounded streaming-upload server surface.
+ * Consumers must check this exact value before relying on streaming backend
+ * uploads, upload concurrency limits, Bearer-only challenges, or error mapping.
+ */
+export const JMAP_SERVER_STREAMING_API_VERSION = 1 as const;
 
 /** Options for constructing a JmapServer. */
 export interface IJmapServerOptions {
@@ -30,16 +38,49 @@ export interface IJmapServerOptions {
    * `addUser`/`addBearerToken`.
    */
   authenticate?: (request: Request) => Promise<TJmapPrincipal | null>;
+  /**
+   * WWW-Authenticate challenges advertised on a 401 response. Defaults to
+   * Bearer and Basic for the built-in registry. Custom authenticators should
+   * list only the schemes they actually accept.
+   */
+  authenticationChallenges?: string[];
   /**
    * Absolute base URL (e.g. `https://mail.example.com`) prefixed to the URLs
    * advertised in the session object. Defaults to relative URLs, which JMAP
    * clients resolve against the session resource URL.
    */
   baseUrl?: string;
+  /** Overrides for the limits advertised in the JMAP session and enforced by this server. */
+  limits?: Partial<IJmapServerLimits>;
+  /**
+   * Process-wide upload ceiling across authenticated principals. Must be at
+   * least the advertised per-principal maxConcurrentUpload value.
+   */
+  maxConcurrentUploadServer?: number;
+  /** Maps backend upload failures to an RFC 7807 response instead of a generic 500. */
+  mapUploadError?: (error: unknown) => IJmapUploadProblem | null | undefined;
+}
+
+export interface IJmapServerLimits {
+  maxSizeUpload: number;
+  maxConcurrentUpload: number;
+  maxSizeRequest: number;
+  maxConcurrentRequests: number;
+  maxCallsInRequest: number;
+  maxObjectsInGet: number;
+  maxObjectsInSet: number;
+}
+
+export interface IJmapUploadProblem {
+  status: number;
+  type?: string;
+  detail: string;
+  limit?: string;
+  retryAfterSeconds?: number;
 }
 
 /** The advertised — and enforced — RFC 8620 core limits. */
-export const JMAP_SERVER_LIMITS = {
+export const JMAP_SERVER_LIMITS: IJmapServerLimits = {
   maxSizeUpload: 50_000_000,
   maxConcurrentUpload: 4,
   maxSizeRequest: 10_000_000,
@@ -50,62 +91,62 @@ export const JMAP_SERVER_LIMITS = {
 };
 
 /** The session object never changes at runtime, so its state is constant. */
-const SESSION_STATE = '0';
+const SESSION_STATE = "0";
 
 /** Default Email/get properties per RFC 8621 §4.2. */
 const DEFAULT_EMAIL_PROPERTIES = [
-  'id',
-  'blobId',
-  'threadId',
-  'mailboxIds',
-  'keywords',
-  'size',
-  'receivedAt',
-  'messageId',
-  'inReplyTo',
-  'references',
-  'sender',
-  'from',
-  'to',
-  'cc',
-  'bcc',
-  'replyTo',
-  'subject',
-  'sentAt',
-  'hasAttachment',
-  'preview',
-  'bodyValues',
-  'textBody',
-  'htmlBody',
-  'attachments',
+  "id",
+  "blobId",
+  "threadId",
+  "mailboxIds",
+  "keywords",
+  "size",
+  "receivedAt",
+  "messageId",
+  "inReplyTo",
+  "references",
+  "sender",
+  "from",
+  "to",
+  "cc",
+  "bcc",
+  "replyTo",
+  "subject",
+  "sentAt",
+  "hasAttachment",
+  "preview",
+  "bodyValues",
+  "textBody",
+  "htmlBody",
+  "attachments",
 ];
 const KNOWN_EMAIL_PROPERTIES = new Set(DEFAULT_EMAIL_PROPERTIES);
 
 const MAILBOX_PROPERTIES = [
-  'id',
-  'name',
-  'parentId',
-  'role',
-  'sortOrder',
-  'totalEmails',
-  'unreadEmails',
-  'totalThreads',
-  'unreadThreads',
-  'myRights',
-  'isSubscribed',
+  "id",
+  "name",
+  "parentId",
+  "role",
+  "sortOrder",
+  "totalEmails",
+  "unreadEmails",
+  "totalThreads",
+  "unreadThreads",
+  "myRights",
+  "isSubscribed",
 ];
 const KNOWN_MAILBOX_PROPERTIES = new Set(MAILBOX_PROPERTIES);
 
 const SUPPORTED_EMAIL_FILTER_KEYS = new Set([
-  'inMailbox',
-  'text',
-  'subject',
-  'from',
-  'to',
-  'before',
-  'after',
-  'hasKeyword',
-  'notKeyword',
+  "inMailbox",
+  "text",
+  "subject",
+  "from",
+  "to",
+  "before",
+  "after",
+  "hasKeyword",
+  "notKeyword",
 ]);
 
 const DEFAULT_MAILBOX_RIGHTS = {
@@ -124,7 +165,9 @@ const textEncoder = new TextEncoder();
 
 /** Ensures bytes are backed by a plain ArrayBuffer so they satisfy BodyInit. */
 const asBodyBytes = (data: Uint8Array): Uint8Array<ArrayBuffer> =>
-  data.buffer instanceof ArrayBuffer ? (data as Uint8Array<ArrayBuffer>) : new Uint8Array(data);
+  data.buffer instanceof ArrayBuffer
+    ? (data as Uint8Array<ArrayBuffer>)
+    : new Uint8Array(data);
 
 /** Error type used inside method dispatch; rendered as a JMAP `error` method response. */
 class JmapServerMethodError extends Error {
@@ -133,6 +176,14 @@ class JmapServerMethodError extends Error {
   }
 }
 
+class JmapRequestBodyError extends Error {
+  constructor(
+    public readonly reason: "invalidLength" | "lengthMismatch" | "tooLarge",
+  ) {
+    super(reason);
+  }
+}
+
 /** One live event-source stream (SSE) with its filters and keepalive timer. */
 interface IEventStreamState {
   accountId: string;
@@ -165,32 +216,37 @@ const truncateUtf8 = (value: string, maxBytes: number): string => {
  * flattening one array level. Throws on any unresolvable path.
  */
 const evalJsonPointer = (root: any, pointer: string): any => {
-  if (pointer === '') {
+  if (pointer === "") {
     return root;
   }
-  if (!pointer.startsWith('/')) {
+  if (!pointer.startsWith("/")) {
     throw new Error(`Invalid JSON pointer "${pointer}".`);
   }
-  const tokens = pointer.slice(1).split('/');
+  const tokens = pointer.slice(1).split("/");
   const evaluate = (value: any, index: number): any => {
     if (index === tokens.length) {
       return value;
     }
-    const token = tokens[index]!.replaceAll('~1', '/').replaceAll('~0', '~');
+    const token = tokens[index]!.replaceAll("~1", "/").replaceAll("~0", "~");
     if (Array.isArray(value)) {
-      if (token === '*') {
+      if (token === "*") {
         const results = value.map((item) => evaluate(item, index + 1));
         return results.some((result) => Array.isArray(result))
-          ? results.flatMap((result) => (Array.isArray(result) ? result : [result]))
+          ? results.flatMap((
+            result,
+          ) => (Array.isArray(result) ? result : [result]))
           : results;
       }
       const arrayIndex = Number(token);
-      if (!Number.isInteger(arrayIndex) || arrayIndex < 0 || arrayIndex >= value.length) {
+      if (
+        !Number.isInteger(arrayIndex) || arrayIndex < 0 ||
+        arrayIndex >= value.length
+      ) {
         throw new Error(`JSON pointer index "${token}" is out of range.`);
       }
       return evaluate(value[arrayIndex], index + 1);
     }
-    if (value !== null && typeof value === 'object' && token in value) {
+    if (value !== null && typeof value === "object" && token in value) {
       return evaluate(value[token], index + 1);
     }
     throw new Error(`JSON pointer token "${token}" does not resolve.`);
@@ -217,16 +273,62 @@ const evalJsonPointer = (root: any, pointer: string): any => {
 export class JmapServer {
   public readonly backend: IJmapMailBackend;
   private options: IJmapServerOptions;
-  private registry: Map<string, { password: string; bearerTokens: Set<string> }> = new Map();
+  private readonly limits: IJmapServerLimits;
+  private readonly maxConcurrentUploadServer: number;
+  private registry: Map<
+    string,
+    { password: string; bearerTokens: Set<string> }
+  > = new Map();
   private httpServer: plugins.http.Server | null = null;
   private sockets: Set<plugins.net.Socket> = new Set();
   private eventStreams: Set<IEventStreamState> = new Set();
   private changeFeedUnsubscribe: (() => void) | null = null;
+  private cleanupErrors: unknown[] = [];
   private activeApiRequests = 0;
+  private activeUploadRequests = 0;
+  private activeUploadsByPrincipal = new Map<string, number>();
+  private activeNodeRequests = new Set<Promise<void>>();
+  private nodeRequestControllers = new Set<AbortController>();
+  private stopping = false;
+  private authenticationChallenges: string;
 
   constructor(options: IJmapServerOptions = {}) {
     this.options = options;
     this.backend = options.backend ?? new MemoryMailBackend();
+    const authenticationChallenges = options.authenticationChallenges ?? [
+      'Bearer realm="jmap"',
+      'Basic realm="jmap"',
+    ];
+    if (
+      authenticationChallenges.length === 0 ||
+      authenticationChallenges.some((challenge) =>
+        typeof challenge !== "string" || !challenge.trim() ||
+        /[\r\n]/.test(challenge)
+      )
+    ) {
+      throw new Error(
+        "authenticationChallenges must contain safe non-empty challenge values.",
+      );
+    }
+    this.authenticationChallenges = authenticationChallenges
+      .map((value) => value.trim())
+      .join(", ");
+    this.limits = { ...JMAP_SERVER_LIMITS, ...options.limits };
+    for (const [name, value] of Object.entries(this.limits)) {
+      if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error(`JMAP limit ${name} must be a positive safe integer.`);
+      }
+    }
+    this.maxConcurrentUploadServer = options.maxConcurrentUploadServer ??
+      this.limits.maxConcurrentUpload;
+    if (
+      !Number.isSafeInteger(this.maxConcurrentUploadServer) ||
+      this.maxConcurrentUploadServer < this.limits.maxConcurrentUpload
+    ) {
+      throw new Error(
+        "maxConcurrentUploadServer must be a safe integer at least as large as maxConcurrentUpload.",
+      );
+    }
   }
 
   // ======================
@@ -261,25 +363,69 @@ export class JmapServer {
   /** Starts a node:http server around fetchHandler. Resolves with the bound port (pass 0 for ephemeral). */
   public start(port: number): Promise<number> {
     if (this.httpServer) {
-      throw new Error('JmapServer is already started.');
+      throw new Error("JmapServer is already started.");
     }
+    this.stopping = false;
     const server = plugins.http.createServer((req, res) => {
-      void this.handleNodeRequest(req, res);
+      if (this.stopping) {
+        res.writeHead(503, {
+          "content-type": "application/problem+json",
+          "connection": "close",
+        });
+        res.end(JSON.stringify({
+          type: "about:blank",
+          status: 503,
+          detail: "JMAP server is shutting down.",
+        }));
+        return;
+      }
+      const requestAbortController = new AbortController();
+      this.nodeRequestControllers.add(requestAbortController);
+      let requestTask!: Promise<void>;
+      requestTask = this.handleNodeRequest(req, res, requestAbortController)
+        .finally(() => {
+          this.nodeRequestControllers.delete(requestAbortController);
+          this.activeNodeRequests.delete(requestTask);
+        });
+      this.activeNodeRequests.add(requestTask);
+      void requestTask;
     });
-    server.on('connection', (socket) => {
+    const onConnection = (socket: plugins.net.Socket): void => {
       this.sockets.add(socket);
-      socket.on('close', () => {
+      socket.on("close", () => {
         this.sockets.delete(socket);
       });
-    });
+    };
+    server.on("connection", onConnection);
     this.httpServer = server;
     return new Promise((resolve, reject) => {
-      server.once('error', reject);
-      server.listen(port, () => {
+      const onStartupError = (error: Error): void => {
+        server.off("listening", onListening);
+        server.off("connection", onConnection);
+        if (this.httpServer === server) {
+          this.httpServer = null;
+        }
+        try {
+          server.close(() => undefined);
+        } catch {
+          // The failed listener never reached the listening state.
+        }
+        reject(error);
+      };
+      const onListening = (): void => {
+        server.off("error", onStartupError);
+        server.on("error", (error) => {
+          this.cleanupErrors.push(error);
+        });
         const address = server.address();
-        const boundPort = typeof address === 'object' && address ? address.port : port;
+        const boundPort = typeof address === "object" && address
+          ? address.port
+          : port;
         resolve(boundPort);
-      });
+      };
+      server.once("error", onStartupError);
+      server.once("listening", onListening);
+      server.listen(port);
     });
   }
 
@@ -289,21 +435,37 @@ export class JmapServer {
    * and closes the node listener when one was started.
    */
   public async stop(): Promise<void> {
+    this.stopping = true;
+    const server = this.httpServer;
+    this.httpServer = null;
+    const listenerClosed = server
+      ? new Promise<void>((resolve) => {
+        try {
+          server.close(() => resolve());
+        } catch {
+          resolve();
+        }
+      })
+      : Promise.resolve();
     for (const stream of Array.from(this.eventStreams)) {
       this.closeStream(stream);
     }
+    for (const controller of this.nodeRequestControllers) {
+      if (!controller.signal.aborted) {
+        controller.abort(new Error("JMAP server is shutting down."));
+      }
+    }
     for (const socket of this.sockets) {
       socket.destroy();
     }
     this.sockets.clear();
-    const server = this.httpServer;
-    this.httpServer = null;
-    if (server) {
-      await new Promise<void>((resolve) => {
-        server.close(() => {
-          resolve();
-        });
-      });
+    await listenerClosed;
+    while (this.activeNodeRequests.size) {
+      await Promise.allSettled([...this.activeNodeRequests]);
+    }
+    if (this.cleanupErrors.length) {
+      const errors = this.cleanupErrors.splice(0);
+      throw new AggregateError(errors, "JmapServer cleanup failed");
     }
   }
 
@@ -319,38 +481,53 @@ export class JmapServer {
     try {
       const principal = await this.authenticatePrincipal(request);
       if (!principal) {
-        return this.problemResponse(401, 'about:blank', 'Authentication required', {
-          'www-authenticate': 'Bearer realm="jmap", Basic realm="jmap"',
-        });
+        await this.cancelRequestBody(request, "authentication rejected");
+        return this.problemResponse(
+          401,
+          "about:blank",
+          "Authentication required",
+          {
+            "www-authenticate": this.authenticationChallenges,
+          },
+        );
       }
       const account = await this.backend.resolveAccount(principal);
       if (!account) {
-        return this.problemResponse(403, 'about:blank', 'No account for this principal');
+        await this.cancelRequestBody(request, "account rejected");
+        return this.problemResponse(
+          403,
+          "about:blank",
+          "No account for this principal",
+        );
       }
 
       const url = new URL(request.url);
       const pathname = url.pathname;
       const method = request.method.toUpperCase();
 
-      if (method === 'GET' && (pathname === '/.well-known/jmap' || pathname === '/jmap/session')) {
+      if (
+        method === "GET" &&
+        (pathname === "/.well-known/jmap" || pathname === "/jmap/session")
+      ) {
         return this.handleSession(account, principal);
       }
-      if (method === 'POST' && pathname === '/jmap/api') {
+      if (method === "POST" && pathname === "/jmap/api") {
         return this.handleApi(account, request);
       }
-      if (method === 'POST' && pathname.startsWith('/jmap/upload/')) {
-        return this.handleUpload(account, pathname, request);
+      if (method === "POST" && pathname.startsWith("/jmap/upload/")) {
+        return this.handleUpload(account, principal, pathname, request);
       }
-      if (method === 'GET' && pathname.startsWith('/jmap/download/')) {
+      if (method === "GET" && pathname.startsWith("/jmap/download/")) {
         return this.handleDownload(account, pathname, url);
       }
-      if (method === 'GET' && pathname === '/jmap/eventsource') {
+      if (method === "GET" && pathname === "/jmap/eventsource") {
         return this.handleEventSource(account, url);
       }
-      return this.problemResponse(404, 'about:blank', 'Not found');
+      await this.cancelRequestBody(request, "route rejected");
+      return this.problemResponse(404, "about:blank", "Not found");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      return this.problemResponse(500, 'about:blank', message);
+      return this.problemResponse(500, "about:blank", message);
     }
   }
 
@@ -358,21 +535,23 @@ export class JmapServer {
   // authentication
   // ======================
 
-  private async authenticatePrincipal(request: Request): Promise<TJmapPrincipal | null> {
+  private async authenticatePrincipal(
+    request: Request,
+  ): Promise<TJmapPrincipal | null> {
     if (this.options.authenticate) {
       return this.options.authenticate(request);
     }
-    const header = request.headers.get('authorization');
+    const header = request.headers.get("authorization");
     if (!header) {
       return null;
     }
-    const spaceIndex = header.indexOf(' ');
+    const spaceIndex = header.indexOf(" ");
     if (spaceIndex === -1) {
       return null;
     }
     const scheme = header.slice(0, spaceIndex).toLowerCase();
     const value = header.slice(spaceIndex + 1).trim();
-    if (scheme === 'bearer') {
+    if (scheme === "bearer") {
       for (const [username, entry] of this.registry) {
         if (entry.bearerTokens.has(value)) {
           return { username };
@@ -380,15 +559,17 @@ export class JmapServer {
       }
       return null;
     }
-    if (scheme === 'basic') {
+    if (scheme === "basic") {
       let decoded: string;
       try {
         const binary = atob(value);
-        decoded = new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+        decoded = new TextDecoder().decode(
+          Uint8Array.from(binary, (char) => char.charCodeAt(0)),
+        );
       } catch {
         return null;
       }
-      const colonIndex = decoded.indexOf(':');
+      const colonIndex = decoded.indexOf(":");
       if (colonIndex === -1) {
         return null;
       }
@@ -407,12 +588,15 @@ export class JmapServer {
   // session
   // ======================
 
-  private handleSession(account: IJmapAccountInfo, principal: TJmapPrincipal): Response {
+  private handleSession(
+    account: IJmapAccountInfo,
+    principal: TJmapPrincipal,
+  ): Response {
     const session = {
       capabilities: {
         [JMAP_CORE_CAPABILITY]: {
-          ...JMAP_SERVER_LIMITS,
-          collationAlgorithms: ['i;ascii-casemap'],
+          ...this.limits,
+          collationAlgorithms: ["i;ascii-casemap"],
         },
         [JMAP_MAIL_CAPABILITY]: {},
         [JMAP_SUBMISSION_CAPABILITY]: {},
@@ -427,8 +611,8 @@ export class JmapServer {
               maxMailboxesPerEmail: null,
               maxMailboxDepth: null,
               maxSizeMailboxName: 490,
-              maxSizeAttachmentsPerEmail: JMAP_SERVER_LIMITS.maxSizeUpload,
-              emailQuerySortOptions: ['receivedAt'],
+              maxSizeAttachmentsPerEmail: this.limits.maxSizeUpload,
+              emailQuerySortOptions: ["receivedAt"],
               mayCreateTopLevelMailbox: false,
             },
             [JMAP_SUBMISSION_CAPABILITY]: {
@@ -444,11 +628,13 @@ export class JmapServer {
         [JMAP_SUBMISSION_CAPABILITY]: account.accountId,
       },
       username: principal.username,
-      apiUrl: this.buildUrl('/jmap/api'),
-      downloadUrl: this.buildUrl('/jmap/download/{accountId}/{blobId}/{name}?type={type}'),
-      uploadUrl: this.buildUrl('/jmap/upload/{accountId}'),
+      apiUrl: this.buildUrl("/jmap/api"),
+      downloadUrl: this.buildUrl(
+        "/jmap/download/{accountId}/{blobId}/{name}?type={type}",
+      ),
+      uploadUrl: this.buildUrl("/jmap/upload/{accountId}"),
       eventSourceUrl: this.buildUrl(
-        '/jmap/eventsource?types={types}&closeafter={closeafter}&ping={ping}'
+        "/jmap/eventsource?types={types}&closeafter={closeafter}&ping={ping}",
       ),
       state: SESSION_STATE,
     };
@@ -457,26 +643,52 @@ export class JmapServer {
 
   private buildUrl(path: string): string {
     const base = this.options.baseUrl;
-    return base ? `${base.replace(/\/+$/, '')}${path}` : path;
+    return base ? `${base.replace(/\/+$/, "")}${path}` : path;
   }
 
   // ======================
   // api endpoint
   // ======================
 
-  private async handleApi(account: IJmapAccountInfo, request: Request): Promise<Response> {
-    if (this.activeApiRequests >= JMAP_SERVER_LIMITS.maxConcurrentRequests) {
-      return this.limitResponse(429, 'maxConcurrentRequests', 'Too many concurrent requests.');
+  private async handleApi(
+    account: IJmapAccountInfo,
+    request: Request,
+  ): Promise<Response> {
+    if (this.activeApiRequests >= this.limits.maxConcurrentRequests) {
+      await this.cancelRequestBody(
+        request,
+        "request concurrency limit reached",
+      );
+      return this.limitResponse(
+        429,
+        "maxConcurrentRequests",
+        "Too many concurrent requests.",
+      );
     }
     this.activeApiRequests++;
     try {
-      const bytes = new Uint8Array(await request.arrayBuffer());
-      if (bytes.length > JMAP_SERVER_LIMITS.maxSizeRequest) {
-        return this.limitResponse(
-          400,
-          'maxSizeRequest',
-          `The request is larger than ${JMAP_SERVER_LIMITS.maxSizeRequest} bytes.`
+      let bytes: Uint8Array;
+      try {
+        bytes = await this.readRequestBodyBounded(
+          request,
+          this.limits.maxSizeRequest,
         );
+      } catch (error) {
+        if (error instanceof JmapRequestBodyError) {
+          if (error.reason === "invalidLength") {
+            return this.problemResponse(
+              400,
+              "about:blank",
+              "Invalid Content-Length header.",
+            );
+          }
+          return this.limitResponse(
+            400,
+            "maxSizeRequest",
+            `The request is larger than ${this.limits.maxSizeRequest} bytes.`,
+          );
+        }
+        throw error;
       }
       let parsed: any;
       try {
@@ -484,20 +696,20 @@ export class JmapServer {
       } catch {
         return this.problemResponse(
           400,
-          'urn:ietf:params:jmap:error:notJSON',
-          'The request body is not valid JSON.'
+          "urn:ietf:params:jmap:error:notJSON",
+          "The request body is not valid JSON.",
         );
       }
       if (
         !parsed ||
-        typeof parsed !== 'object' ||
+        typeof parsed !== "object" ||
         !Array.isArray(parsed.using) ||
         !Array.isArray(parsed.methodCalls)
       ) {
         return this.problemResponse(
           400,
-          'urn:ietf:params:jmap:error:notRequest',
-          'The request body is not a valid JMAP request object.'
+          "urn:ietf:params:jmap:error:notRequest",
+          "The request body is not a valid JMAP request object.",
         );
       }
       const knownCapabilities = new Set([
@@ -510,36 +722,52 @@ export class JmapServer {
         if (!knownCapabilities.has(capability)) {
           return this.problemResponse(
             400,
-            'urn:ietf:params:jmap:error:unknownCapability',
-            `The capability "${capability}" is not supported by this server.`
+            "urn:ietf:params:jmap:error:unknownCapability",
+            `The capability "${capability}" is not supported by this server.`,
           );
         }
       }
-      if (parsed.methodCalls.length > JMAP_SERVER_LIMITS.maxCallsInRequest) {
+      if (parsed.methodCalls.length > this.limits.maxCallsInRequest) {
         return this.limitResponse(
           400,
-          'maxCallsInRequest',
-          `The request has more than ${JMAP_SERVER_LIMITS.maxCallsInRequest} method calls.`
+          "maxCallsInRequest",
+          `The request has more than ${this.limits.maxCallsInRequest} method calls.`,
         );
       }
 
       const createdIds = new Map<string, string>(
-        Object.entries((parsed.createdIds ?? {}) as Record<string, string>)
+        Object.entries((parsed.createdIds ?? {}) as Record<string, string>),
       );
       const methodResponses: TJmapMethodResponse[] = [];
       let mutated = false;
       for (const call of parsed.methodCalls) {
-        if (!Array.isArray(call) || typeof call[0] !== 'string' || typeof call[2] !== 'string') {
+        if (
+          !Array.isArray(call) || typeof call[0] !== "string" ||
+          typeof call[2] !== "string"
+        ) {
           return this.problemResponse(
             400,
-            'urn:ietf:params:jmap:error:notRequest',
-            'Each method call must be a [name, arguments, callId] tuple.'
+            "urn:ietf:params:jmap:error:notRequest",
+            "Each method call must be a [name, arguments, callId] tuple.",
           );
         }
-        const [methodName, rawArgs, callId] = call as [string, Record<string, any>, string];
+        const [methodName, rawArgs, callId] = call as [
+          string,
+          Record<string, any>,
+          string,
+        ];
         try {
-          const args = this.resolveBackReferences(rawArgs ?? {}, methodResponses);
-          const results = await this.dispatchMethod(account, methodName, args, using, createdIds);
+          const args = this.resolveBackReferences(
+            rawArgs ?? {},
+            methodResponses,
+          );
+          const results = await this.dispatchMethod(
+            account,
+            methodName,
+            args,
+            using,
+            createdIds,
+          );
           for (const entry of results) {
             methodResponses.push([entry.name, entry.result, callId]);
             if (entry.mutated) {
@@ -549,13 +777,18 @@ export class JmapServer {
         } catch (error) {
           if (error instanceof JmapServerMethodError) {
             methodResponses.push([
-              'error',
+              "error",
               { type: error.type, description: error.message },
               callId,
             ]);
           } else {
-            const message = error instanceof Error ? error.message : String(error);
-            methodResponses.push(['error', { type: 'serverFail', description: message }, callId]);
+            const message = error instanceof Error
+              ? error.message
+              : String(error);
+            methodResponses.push(["error", {
+              type: "serverFail",
+              description: message,
+            }, callId]);
           }
         }
       }
@@ -583,48 +816,48 @@ export class JmapServer {
    */
   private resolveBackReferences(
     args: Record<string, any>,
-    priorResponses: TJmapMethodResponse[]
+    priorResponses: TJmapMethodResponse[],
   ): Record<string, any> {
     const resolved: Record<string, any> = {};
     for (const [key, value] of Object.entries(args)) {
-      if (!key.startsWith('#')) {
+      if (!key.startsWith("#")) {
         resolved[key] = value;
         continue;
       }
       const name = key.slice(1);
       if (name in args) {
         throw new JmapServerMethodError(
-          'invalidArguments',
-          `The arguments contain both "${name}" and "#${name}".`
+          "invalidArguments",
+          `The arguments contain both "${name}" and "#${name}".`,
         );
       }
       if (
         !value ||
-        typeof value !== 'object' ||
-        typeof value.resultOf !== 'string' ||
-        typeof value.name !== 'string' ||
-        typeof value.path !== 'string'
+        typeof value !== "object" ||
+        typeof value.resultOf !== "string" ||
+        typeof value.name !== "string" ||
+        typeof value.path !== "string"
       ) {
         throw new JmapServerMethodError(
-          'invalidResultReference',
-          `"#${name}" is not a valid ResultReference object.`
+          "invalidResultReference",
+          `"#${name}" is not a valid ResultReference object.`,
         );
       }
       const source = priorResponses.find(
-        (entry) => entry[2] === value.resultOf && entry[0] === value.name
+        (entry) => entry[2] === value.resultOf && entry[0] === value.name,
       );
       if (!source) {
         throw new JmapServerMethodError(
-          'invalidResultReference',
-          `No response found for resultOf "${value.resultOf}" and name "${value.name}".`
+          "invalidResultReference",
+          `No response found for resultOf "${value.resultOf}" and name "${value.name}".`,
         );
       }
       try {
         resolved[name] = evalJsonPointer(source[1], value.path);
       } catch (error) {
         throw new JmapServerMethodError(
-          'invalidResultReference',
-          error instanceof Error ? error.message : String(error)
+          "invalidResultReference",
+          error instanceof Error ? error.message : String(error),
         );
       }
     }
@@ -640,80 +873,122 @@ export class JmapServer {
     methodName: string,
     args: Record<string, any>,
     using: Set<string>,
-    createdIds: Map<string, string>
-  ): Promise<Array<{ name: string; result: Record<string, any>; mutated?: boolean }>> {
+    createdIds: Map<string, string>,
+  ): Promise<
+    Array<{ name: string; result: Record<string, any>; mutated?: boolean }>
+  > {
     const requiredCapability: Record<string, string> = {
-      'Core/echo': JMAP_CORE_CAPABILITY,
-      'Mailbox/get': JMAP_MAIL_CAPABILITY,
-      'Mailbox/query': JMAP_MAIL_CAPABILITY,
-      'Mailbox/changes': JMAP_MAIL_CAPABILITY,
-      'Thread/get': JMAP_MAIL_CAPABILITY,
-      'Email/get': JMAP_MAIL_CAPABILITY,
-      'Email/query': JMAP_MAIL_CAPABILITY,
-      'Email/changes': JMAP_MAIL_CAPABILITY,
-      'Email/queryChanges': JMAP_MAIL_CAPABILITY,
-      'Email/set': JMAP_MAIL_CAPABILITY,
-      'Identity/get': JMAP_SUBMISSION_CAPABILITY,
-      'EmailSubmission/set': JMAP_SUBMISSION_CAPABILITY,
+      "Core/echo": JMAP_CORE_CAPABILITY,
+      "Mailbox/get": JMAP_MAIL_CAPABILITY,
+      "Mailbox/query": JMAP_MAIL_CAPABILITY,
+      "Mailbox/changes": JMAP_MAIL_CAPABILITY,
+      "Thread/get": JMAP_MAIL_CAPABILITY,
+      "Email/get": JMAP_MAIL_CAPABILITY,
+      "Email/query": JMAP_MAIL_CAPABILITY,
+      "Email/changes": JMAP_MAIL_CAPABILITY,
+      "Email/queryChanges": JMAP_MAIL_CAPABILITY,
+      "Email/set": JMAP_MAIL_CAPABILITY,
+      "Identity/get": JMAP_SUBMISSION_CAPABILITY,
+      "EmailSubmission/set": JMAP_SUBMISSION_CAPABILITY,
     };
     const capability = requiredCapability[methodName];
     if (!capability) {
-      throw new JmapServerMethodError('unknownMethod', `Unknown method "${methodName}".`);
+      throw new JmapServerMethodError(
+        "unknownMethod",
+        `Unknown method "${methodName}".`,
+      );
     }
     if (!using.has(capability)) {
       throw new JmapServerMethodError(
-        'unknownMethod',
-        `Method "${methodName}" requires the capability "${capability}" in "using".`
+        "unknownMethod",
+        `Method "${methodName}" requires the capability "${capability}" in "using".`,
       );
     }
-    if (methodName !== 'Core/echo') {
+    if (methodName !== "Core/echo") {
       this.requireAccountId(account, args);
     }
 
     switch (methodName) {
-      case 'Core/echo':
+      case "Core/echo":
         return [{ name: methodName, result: args }];
-      case 'Mailbox/get':
-        return [{ name: methodName, result: await this.methodMailboxGet(account, args) }];
-      case 'Mailbox/query':
-        return [{ name: methodName, result: await this.methodMailboxQuery(account, args) }];
-      case 'Mailbox/changes':
-        return [{ name: methodName, result: await this.methodMailboxChanges(account, args) }];
-      case 'Thread/get':
-        return [{ name: methodName, result: await this.methodThreadGet(account, args) }];
-      case 'Email/get':
-        return [{ name: methodName, result: await this.methodEmailGet(account, args) }];
-      case 'Email/query':
-        return [{ name: methodName, result: await this.methodEmailQuery(account, args) }];
-      case 'Email/changes':
-        return [{ name: methodName, result: await this.methodEmailChanges(account, args) }];
-      case 'Email/queryChanges':
+      case "Mailbox/get":
+        return [{
+          name: methodName,
+          result: await this.methodMailboxGet(account, args),
+        }];
+      case "Mailbox/query":
+        return [{
+          name: methodName,
+          result: await this.methodMailboxQuery(account, args),
+        }];
+      case "Mailbox/changes":
+        return [{
+          name: methodName,
+          result: await this.methodMailboxChanges(account, args),
+        }];
+      case "Thread/get":
+        return [{
+          name: methodName,
+          result: await this.methodThreadGet(account, args),
+        }];
+      case "Email/get":
+        return [{
+          name: methodName,
+          result: await this.methodEmailGet(account, args),
+        }];
+      case "Email/query":
+        return [{
+          name: methodName,
+          result: await this.methodEmailQuery(account, args),
+        }];
+      case "Email/changes":
+        return [{
+          name: methodName,
+          result: await this.methodEmailChanges(account, args),
+        }];
+      case "Email/queryChanges":
         // Explicitly unsupported in phase 1: clients fall back to Email/query.
         throw new JmapServerMethodError(
-          'cannotCalculateChanges',
-          'Email/queryChanges is not supported; re-run the query instead.'
+          "cannotCalculateChanges",
+          "Email/queryChanges is not supported; re-run the query instead.",
         );
-      case 'Email/set': {
+      case "Email/set": {
         const result = await this.methodEmailSet(account, args, createdIds);
-        return [{ name: methodName, result, mutated: result.newState !== result.oldState }];
-      }
-      case 'Identity/get':
-        return [{ name: methodName, result: await this.methodIdentityGet(account, args) }];
-      case 'EmailSubmission/set':
+        return [{
+          name: methodName,
+          result,
+          mutated: result.newState !== result.oldState,
+        }];
+      }
+      case "Identity/get":
+        return [{
+          name: methodName,
+          result: await this.methodIdentityGet(account, args),
+        }];
+      case "EmailSubmission/set":
         return this.methodEmailSubmissionSet(account, args, createdIds);
       default:
-        throw new JmapServerMethodError('unknownMethod', `Unknown method "${methodName}".`);
+        throw new JmapServerMethodError(
+          "unknownMethod",
+          `Unknown method "${methodName}".`,
+        );
     }
   }
 
-  private requireAccountId(account: IJmapAccountInfo, args: Record<string, any>): void {
-    if (typeof args.accountId !== 'string') {
-      throw new JmapServerMethodError('invalidArguments', 'accountId is required.');
+  private requireAccountId(
+    account: IJmapAccountInfo,
+    args: Record<string, any>,
+  ): void {
+    if (typeof args.accountId !== "string") {
+      throw new JmapServerMethodError(
+        "invalidArguments",
+        "accountId is required.",
+      );
     }
     if (args.accountId !== account.accountId) {
       throw new JmapServerMethodError(
-        'accountNotFound',
-        `Account "${args.accountId}" is not accessible with these credentials.`
+        "accountNotFound",
+        `Account "${args.accountId}" is not accessible with these credentials.`,
       );
     }
   }
@@ -724,22 +999,28 @@ export class JmapServer {
 
   private async methodMailboxGet(
     account: IJmapAccountInfo,
-    args: Record<string, any>
+    args: Record<string, any>,
   ): Promise<Record<string, any>> {
     let ids: string[] | null = null;
     if (args.ids !== null && args.ids !== undefined) {
       if (!Array.isArray(args.ids)) {
-        throw new JmapServerMethodError('invalidArguments', 'ids must be an array of ids or null.');
+        throw new JmapServerMethodError(
+          "invalidArguments",
+          "ids must be an array of ids or null.",
+        );
       }
-      if (args.ids.length > JMAP_SERVER_LIMITS.maxObjectsInGet) {
+      if (args.ids.length > this.limits.maxObjectsInGet) {
         throw new JmapServerMethodError(
-          'requestTooLarge',
-          `ids exceeds maxObjectsInGet (${JMAP_SERVER_LIMITS.maxObjectsInGet}).`
+          "requestTooLarge",
+          `ids exceeds maxObjectsInGet (${this.limits.maxObjectsInGet}).`,
         );
       }
       ids = args.ids as string[];
     }
-    const properties = this.validateProperties(args.properties, KNOWN_MAILBOX_PROPERTIES);
+    const properties = this.validateProperties(
+      args.properties,
+      KNOWN_MAILBOX_PROPERTIES,
+    );
     const result = await this.backend.getMailboxes(account.accountId, ids);
     const list = result.list.map((mailbox) => {
       const full: Record<string, any> = {
@@ -759,48 +1040,50 @@ export class JmapServer {
 
   private async methodMailboxQuery(
     account: IJmapAccountInfo,
-    args: Record<string, any>
+    args: Record<string, any>,
   ): Promise<Record<string, any>> {
     const filter = (args.filter ?? {}) as Record<string, any>;
-    if ('operator' in filter) {
+    if ("operator" in filter) {
       throw new JmapServerMethodError(
-        'unsupportedFilter',
-        'FilterOperator is not supported for Mailbox/query.'
+        "unsupportedFilter",
+        "FilterOperator is not supported for Mailbox/query.",
       );
     }
     for (const key of Object.keys(filter)) {
-      if (!['role', 'name', 'parentId'].includes(key)) {
+      if (!["role", "name", "parentId"].includes(key)) {
         throw new JmapServerMethodError(
-          'unsupportedFilter',
-          `Mailbox filter condition "${key}" is not supported.`
+          "unsupportedFilter",
+          `Mailbox filter condition "${key}" is not supported.`,
         );
       }
     }
     for (const comparator of (args.sort ?? []) as Array<Record<string, any>>) {
-      if (!['name', 'sortOrder'].includes(comparator.property)) {
+      if (!["name", "sortOrder"].includes(comparator.property)) {
         throw new JmapServerMethodError(
-          'unsupportedSort',
-          `Mailbox sort property "${comparator.property}" is not supported.`
+          "unsupportedSort",
+          `Mailbox sort property "${comparator.property}" is not supported.`,
         );
       }
     }
     const result = await this.backend.getMailboxes(account.accountId, null);
     let mailboxes = result.list;
-    if (typeof filter.role === 'string') {
+    if (typeof filter.role === "string") {
       mailboxes = mailboxes.filter((mailbox) => mailbox.role === filter.role);
     }
-    if (typeof filter.name === 'string') {
+    if (typeof filter.name === "string") {
       mailboxes = mailboxes.filter((mailbox) => mailbox.name === filter.name);
     }
-    if ('parentId' in filter) {
-      mailboxes = mailboxes.filter((mailbox) => mailbox.parentId === filter.parentId);
+    if ("parentId" in filter) {
+      mailboxes = mailboxes.filter((mailbox) =>
+        mailbox.parentId === filter.parentId
+      );
     }
     const comparators = (args.sort ?? []) as Array<Record<string, any>>;
     if (comparators.length) {
       mailboxes = [...mailboxes].sort((a, b) => {
         for (const comparator of comparators) {
           const direction = comparator.isAscending === false ? -1 : 1;
-          const property = comparator.property as 'name' | 'sortOrder';
+          const property = comparator.property as "name" | "sortOrder";
           const left = a[property] ?? 0;
           const right = b[property] ?? 0;
           if (left < right) {
@@ -815,7 +1098,7 @@ export class JmapServer {
     }
     const position = this.validatePosition(args);
     let ids = mailboxes.map((mailbox) => mailbox.id).slice(position);
-    if (typeof args.limit === 'number') {
+    if (typeof args.limit === "number") {
       ids = ids.slice(0, args.limit);
     }
     const response: Record<string, any> = {
@@ -833,14 +1116,18 @@ export class JmapServer {
 
   private async methodMailboxChanges(
     account: IJmapAccountInfo,
-    args: Record<string, any>
+    args: Record<string, any>,
   ): Promise<Record<string, any>> {
     const { sinceState, maxChanges } = this.validateChangesArgs(args);
-    const changes = await this.backend.getMailboxChanges(account.accountId, sinceState, maxChanges);
+    const changes = await this.backend.getMailboxChanges(
+      account.accountId,
+      sinceState,
+      maxChanges,
+    );
     if (!changes) {
       throw new JmapServerMethodError(
-        'cannotCalculateChanges',
-        `Cannot calculate mailbox changes since state "${sinceState}".`
+        "cannotCalculateChanges",
+        `Cannot calculate mailbox changes since state "${sinceState}".`,
       );
     }
     return { accountId: account.accountId, ...changes };
@@ -852,15 +1139,18 @@ export class JmapServer {
 
   private async methodThreadGet(
     account: IJmapAccountInfo,
-    args: Record<string, any>
+    args: Record<string, any>,
   ): Promise<Record<string, any>> {
     if (!Array.isArray(args.ids)) {
-      throw new JmapServerMethodError('invalidArguments', 'Thread/get requires an ids array.');
+      throw new JmapServerMethodError(
+        "invalidArguments",
+        "Thread/get requires an ids array.",
+      );
     }
-    if (args.ids.length > JMAP_SERVER_LIMITS.maxObjectsInGet) {
+    if (args.ids.length > this.limits.maxObjectsInGet) {
       throw new JmapServerMethodError(
-        'requestTooLarge',
-        `ids exceeds maxObjectsInGet (${JMAP_SERVER_LIMITS.maxObjectsInGet}).`
+        "requestTooLarge",
+        `ids exceeds maxObjectsInGet (${this.limits.maxObjectsInGet}).`,
       );
     }
     // Result-reference chains like Email/get -> /list/*/threadId commonly
@@ -881,30 +1171,40 @@ export class JmapServer {
 
   private async methodEmailGet(
     account: IJmapAccountInfo,
-    args: Record<string, any>
+    args: Record<string, any>,
   ): Promise<Record<string, any>> {
     if (args.ids === null || args.ids === undefined) {
       // RFC 8621 allows rejecting "fetch all" for the potentially huge Email type.
       throw new JmapServerMethodError(
-        'requestTooLarge',
-        'Email/get requires an explicit ids array on this server.'
+        "requestTooLarge",
+        "Email/get requires an explicit ids array on this server.",
       );
     }
     if (!Array.isArray(args.ids)) {
-      throw new JmapServerMethodError('invalidArguments', 'Email/get requires an ids array.');
+      throw new JmapServerMethodError(
+        "invalidArguments",
+        "Email/get requires an ids array.",
+      );
     }
-    if (args.ids.length > JMAP_SERVER_LIMITS.maxObjectsInGet) {
+    if (args.ids.length > this.limits.maxObjectsInGet) {
       throw new JmapServerMethodError(
-        'requestTooLarge',
-        `ids exceeds maxObjectsInGet (${JMAP_SERVER_LIMITS.maxObjectsInGet}).`
+        "requestTooLarge",
+        `ids exceeds maxObjectsInGet (${this.limits.maxObjectsInGet}).`,
       );
     }
-    const properties = this.validateProperties(args.properties, KNOWN_EMAIL_PROPERTIES);
-    const result = await this.backend.getEmails(account.accountId, args.ids as string[], properties);
+    const properties = this.validateProperties(
+      args.properties,
+      KNOWN_EMAIL_PROPERTIES,
+    );
+    const result = await this.backend.getEmails(
+      account.accountId,
+      args.ids as string[],
+      properties,
+    );
     const effectiveProperties = properties ?? DEFAULT_EMAIL_PROPERTIES;
     const list = result.list.map((record) => {
       const projected = this.projectObject(record as any, effectiveProperties);
-      if (effectiveProperties.includes('bodyValues')) {
+      if (effectiveProperties.includes("bodyValues")) {
         projected.bodyValues = this.buildBodyValues(record, args);
       }
       return projected;
@@ -920,7 +1220,7 @@ export class JmapServer {
   /** Applies the Email/get body-value fetch flags and maxBodyValueBytes truncation. */
   private buildBodyValues(
     record: IJmapEmailRecord,
-    args: Record<string, any>
+    args: Record<string, any>,
   ): Record<string, IJmapEmailBodyValue> {
     const wanted = new Set<string>();
     if (args.fetchAllBodyValues === true) {
@@ -943,7 +1243,7 @@ export class JmapServer {
       }
     }
     const maxBytes =
-      typeof args.maxBodyValueBytes === 'number' && args.maxBodyValueBytes > 0
+      typeof args.maxBodyValueBytes === "number" && args.maxBodyValueBytes > 0
         ? args.maxBodyValueBytes
         : null;
     const result: Record<string, IJmapEmailBodyValue> = {};
@@ -968,41 +1268,44 @@ export class JmapServer {
 
   private async methodEmailQuery(
     account: IJmapAccountInfo,
-    args: Record<string, any>
+    args: Record<string, any>,
   ): Promise<Record<string, any>> {
     const filter = (args.filter ?? {}) as Record<string, any>;
-    if ('operator' in filter) {
+    if ("operator" in filter) {
       throw new JmapServerMethodError(
-        'unsupportedFilter',
-        'FilterOperator is not supported; use a flat FilterCondition.'
+        "unsupportedFilter",
+        "FilterOperator is not supported; use a flat FilterCondition.",
       );
     }
     for (const key of Object.keys(filter)) {
       if (!SUPPORTED_EMAIL_FILTER_KEYS.has(key)) {
         throw new JmapServerMethodError(
-          'unsupportedFilter',
-          `Email filter condition "${key}" is not supported.`
+          "unsupportedFilter",
+          `Email filter condition "${key}" is not supported.`,
         );
       }
     }
     const sort = (args.sort ?? []) as Array<Record<string, any>>;
     for (const comparator of sort) {
-      if (comparator.property !== 'receivedAt') {
+      if (comparator.property !== "receivedAt") {
         throw new JmapServerMethodError(
-          'unsupportedSort',
-          `Email sort property "${comparator.property}" is not supported.`
+          "unsupportedSort",
+          `Email sort property "${comparator.property}" is not supported.`,
         );
       }
     }
     if (args.anchor !== undefined && args.anchor !== null) {
-      throw new JmapServerMethodError('invalidArguments', 'anchor is not supported.');
+      throw new JmapServerMethodError(
+        "invalidArguments",
+        "anchor is not supported.",
+      );
     }
     const position = this.validatePosition(args);
     const result = await this.backend.queryEmails(account.accountId, {
       filter: filter as IJmapEmailFilter,
       sort: sort as Array<{ property: string; isAscending?: boolean }>,
       position,
-      limit: typeof args.limit === 'number' ? args.limit : null,
+      limit: typeof args.limit === "number" ? args.limit : null,
       calculateTotal: args.calculateTotal === true,
     });
     const response: Record<string, any> = {
@@ -1020,14 +1323,18 @@ export class JmapServer {
 
   private async methodEmailChanges(
     account: IJmapAccountInfo,
-    args: Record<string, any>
+    args: Record<string, any>,
   ): Promise<Record<string, any>> {
     const { sinceState, maxChanges } = this.validateChangesArgs(args);
-    const changes = await this.backend.getEmailChanges(account.accountId, sinceState, maxChanges);
+    const changes = await this.backend.getEmailChanges(
+      account.accountId,
+      sinceState,
+      maxChanges,
+    );
     if (!changes) {
       throw new JmapServerMethodError(
-        'cannotCalculateChanges',
-        `Cannot calculate changes since state "${sinceState}".`
+        "cannotCalculateChanges",
+        `Cannot calculate changes since state "${sinceState}".`,
       );
     }
     return { accountId: account.accountId, ...changes };
@@ -1036,26 +1343,30 @@ export class JmapServer {
   private async methodEmailSet(
     account: IJmapAccountInfo,
     args: Record<string, any>,
-    createdIds: Map<string, string>
+    createdIds: Map<string, string>,
   ): Promise<Record<string, any>> {
-    const createEntries = Object.entries((args.create ?? {}) as Record<string, any>);
-    const updateEntries = Object.entries((args.update ?? {}) as Record<string, any>);
+    const createEntries = Object.entries(
+      (args.create ?? {}) as Record<string, any>,
+    );
+    const updateEntries = Object.entries(
+      (args.update ?? {}) as Record<string, any>,
+    );
     const destroyIds = (args.destroy ?? []) as string[];
     if (
       createEntries.length + updateEntries.length + destroyIds.length >
-      JMAP_SERVER_LIMITS.maxObjectsInSet
+        this.limits.maxObjectsInSet
     ) {
       throw new JmapServerMethodError(
-        'requestTooLarge',
-        `The set request exceeds maxObjectsInSet (${JMAP_SERVER_LIMITS.maxObjectsInSet}).`
+        "requestTooLarge",
+        `The set request exceeds maxObjectsInSet (${this.limits.maxObjectsInSet}).`,
       );
     }
-    if (typeof args.ifInState === 'string') {
+    if (typeof args.ifInState === "string") {
       const current = await this.backend.getEmails(account.accountId, []);
       if (current.state !== args.ifInState) {
         throw new JmapServerMethodError(
-          'stateMismatch',
-          `ifInState "${args.ifInState}" does not match the current state "${current.state}".`
+          "stateMismatch",
+          `ifInState "${args.ifInState}" does not match the current state "${current.state}".`,
         );
       }
     }
@@ -1073,12 +1384,13 @@ export class JmapServer {
       backendRequest.update = {};
       for (const [id, patch] of updateEntries) {
         try {
-          backendRequest.update[id] = this.parseEmailUpdatePatch(patch as Record<string, any>);
+          backendRequest.update[id] = this.parseEmailUpdatePatch(
+            patch as Record<string, any>,
+          );
         } catch (error) {
-          notUpdatedEarly[id] =
-            error instanceof JmapServerMethodError
-              ? { type: error.type, description: error.message }
-              : { type: 'invalidPatch', description: String(error) };
+          notUpdatedEarly[id] = error instanceof JmapServerMethodError
+            ? { type: error.type, description: error.message }
+            : { type: "invalidPatch", description: String(error) };
         }
       }
     }
@@ -1086,7 +1398,10 @@ export class JmapServer {
       backendRequest.destroy = destroyIds;
     }
 
-    const result = await this.backend.setEmails(account.accountId, backendRequest);
+    const result = await this.backend.setEmails(
+      account.accountId,
+      backendRequest,
+    );
 
     const created: Record<string, any> = {};
     for (const [creationId, record] of Object.entries(result.created)) {
@@ -1123,18 +1438,28 @@ export class JmapServer {
    */
   private parseEmailUpdatePatch(patch: Record<string, any>): IJmapEmailUpdate {
     const update: IJmapEmailUpdate = {};
-    const unescape = (token: string): string => token.replaceAll('~1', '/').replaceAll('~0', '~');
+    const unescape = (token: string): string =>
+      token.replaceAll("~1", "/").replaceAll("~0", "~");
     for (const [path, value] of Object.entries(patch)) {
-      if (path === 'keywords' || path === 'mailboxIds') {
-        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-          throw new JmapServerMethodError('invalidProperties', `"${path}" must be an object.`);
+      if (path === "keywords" || path === "mailboxIds") {
+        if (
+          value === null || typeof value !== "object" || Array.isArray(value)
+        ) {
+          throw new JmapServerMethodError(
+            "invalidProperties",
+            `"${path}" must be an object.`,
+          );
         }
         const normalized: Record<string, boolean> = {};
-        for (const [key, entryValue] of Object.entries(value as Record<string, any>)) {
+        for (
+          const [key, entryValue] of Object.entries(
+            value as Record<string, any>,
+          )
+        ) {
           if (entryValue !== true) {
             throw new JmapServerMethodError(
-              'invalidProperties',
-              `Values in "${path}" must be true; remove entries instead of setting them false.`
+              "invalidProperties",
+              `Values in "${path}" must be true; remove entries instead of setting them false.`,
             );
           }
           normalized[key] = true;
@@ -1142,27 +1467,37 @@ export class JmapServer {
         update[path] = normalized;
         continue;
       }
-      const slashIndex = path.indexOf('/');
+      const slashIndex = path.indexOf("/");
       if (slashIndex === -1) {
         throw new JmapServerMethodError(
-          'invalidProperties',
-          `Email property "${path}" is immutable or unknown.`
+          "invalidProperties",
+          `Email property "${path}" is immutable or unknown.`,
         );
       }
       const property = path.slice(0, slashIndex);
       const rest = path.slice(slashIndex + 1);
-      if ((property !== 'keywords' && property !== 'mailboxIds') || rest.includes('/') || !rest) {
-        throw new JmapServerMethodError('invalidPatch', `Unsupported patch path "${path}".`);
+      if (
+        (property !== "keywords" && property !== "mailboxIds") ||
+        rest.includes("/") || !rest
+      ) {
+        throw new JmapServerMethodError(
+          "invalidPatch",
+          `Unsupported patch path "${path}".`,
+        );
       }
       const key = unescape(rest);
-      const normalizedValue = value === true ? true : value === null || value === false ? null : undefined;
+      const normalizedValue = value === true
+        ? true
+        : value === null || value === false
+        ? null
+        : undefined;
       if (normalizedValue === undefined) {
         throw new JmapServerMethodError(
-          'invalidPatch',
-          `Patch value for "${path}" must be true or null.`
+          "invalidPatch",
+          `Patch value for "${path}" must be true or null.`,
         );
       }
-      if (property === 'keywords') {
+      if (property === "keywords") {
         update.keywordsPatch = update.keywordsPatch ?? {};
         update.keywordsPatch[key] = normalizedValue;
       } else {
@@ -1172,14 +1507,14 @@ export class JmapServer {
     }
     if (update.keywords && update.keywordsPatch) {
       throw new JmapServerMethodError(
-        'invalidPatch',
-        'A patch must not set "keywords" and patch "keywords/..." at the same time.'
+        "invalidPatch",
+        'A patch must not set "keywords" and patch "keywords/..." at the same time.',
       );
     }
     if (update.mailboxIds && update.mailboxIdsPatch) {
       throw new JmapServerMethodError(
-        'invalidPatch',
-        'A patch must not set "mailboxIds" and patch "mailboxIds/..." at the same time.'
+        "invalidPatch",
+        'A patch must not set "mailboxIds" and patch "mailboxIds/..." at the same time.',
       );
     }
     return update;
@@ -1191,7 +1526,7 @@ export class JmapServer {
 
   private async methodIdentityGet(
     account: IJmapAccountInfo,
-    args: Record<string, any>
+    args: Record<string, any>,
   ): Promise<Record<string, any>> {
     const result = await this.backend.getIdentities(account.accountId);
     let list = result.list;
@@ -1205,67 +1540,90 @@ export class JmapServer {
         }
       }
     }
-    return { accountId: account.accountId, state: result.state, list, notFound };
+    return {
+      accountId: account.accountId,
+      state: result.state,
+      list,
+      notFound,
+    };
   }
 
   private async methodEmailSubmissionSet(
     account: IJmapAccountInfo,
     args: Record<string, any>,
-    createdIds: Map<string, string>
-  ): Promise<Array<{ name: string; result: Record<string, any>; mutated?: boolean }>> {
+    createdIds: Map<string, string>,
+  ): Promise<
+    Array<{ name: string; result: Record<string, any>; mutated?: boolean }>
+  > {
     const created: Record<string, any> = {};
     const notCreated: Record<string, IJmapSetError> = {};
     const notUpdated: Record<string, IJmapSetError> = {};
     const notDestroyed: Record<string, IJmapSetError> = {};
     /** creationId -> { submissionId, emailId } for onSuccess* resolution. */
-    const createdSubmissions = new Map<string, { submissionId: string; emailId: string }>();
+    const createdSubmissions = new Map<
+      string,
+      { submissionId: string; emailId: string }
+    >();
 
-    const identitiesResult = await this.backend.getIdentities(account.accountId);
+    const identitiesResult = await this.backend.getIdentities(
+      account.accountId,
+    );
 
-    for (const [creationId, spec] of Object.entries((args.create ?? {}) as Record<string, any>)) {
+    for (
+      const [creationId, spec] of Object.entries(
+        (args.create ?? {}) as Record<string, any>,
+      )
+    ) {
       let emailId: string = spec.emailId;
-      if (typeof emailId === 'string' && emailId.startsWith('#')) {
+      if (typeof emailId === "string" && emailId.startsWith("#")) {
         const resolved = createdIds.get(emailId.slice(1));
         if (!resolved) {
           notCreated[creationId] = {
-            type: 'invalidProperties',
+            type: "invalidProperties",
             description: `Unknown creation id reference "${emailId}".`,
           };
           continue;
         }
         emailId = resolved;
       }
-      const emailResult = await this.backend.getEmails(account.accountId, [emailId]);
+      const emailResult = await this.backend.getEmails(account.accountId, [
+        emailId,
+      ]);
       const email = emailResult.list[0];
       if (!email) {
         notCreated[creationId] = {
-          type: 'invalidProperties',
+          type: "invalidProperties",
           description: `Email "${emailId}" does not exist.`,
         };
         continue;
       }
       const identity = identitiesResult.list.find(
-        (candidate) => candidate.id === spec.identityId
+        (candidate) => candidate.id === spec.identityId,
       );
       if (!identity) {
         notCreated[creationId] = {
-          type: 'invalidProperties',
+          type: "invalidProperties",
           description: `Identity "${spec.identityId}" does not exist.`,
         };
         continue;
       }
-      const envelope = this.resolveEnvelope(spec.envelope, identity.email, email);
+      const envelope = this.resolveEnvelope(
+        spec.envelope,
+        identity.email,
+        email,
+      );
       if (!envelope.rcptTo.length) {
         notCreated[creationId] = {
-          type: 'noRecipients',
-          description: 'The email has no to/cc/bcc recipients and no envelope was given.',
+          type: "noRecipients",
+          description:
+            "The email has no to/cc/bcc recipients and no envelope was given.",
         };
         continue;
       }
       const blob = await this.backend.getBlob(account.accountId, email.blobId);
       if (!blob) {
         notCreated[creationId] = {
-          type: 'invalidProperties',
+          type: "invalidProperties",
           description: `Raw message blob "${email.blobId}" does not exist.`,
         };
         continue;
@@ -1277,7 +1635,10 @@ export class JmapServer {
           envelope,
           message: blob.data,
         });
-        createdSubmissions.set(creationId, { submissionId: submission.id, emailId });
+        createdSubmissions.set(creationId, {
+          submissionId: submission.id,
+          emailId,
+        });
         created[creationId] = {
           id: submission.id,
           undoStatus: submission.undoStatus,
@@ -1285,7 +1646,7 @@ export class JmapServer {
         };
       } catch (error) {
         notCreated[creationId] = {
-          type: 'forbiddenToSend',
+          type: "forbiddenToSend",
           description: error instanceof Error ? error.message : String(error),
         };
       }
@@ -1293,24 +1654,26 @@ export class JmapServer {
 
     for (const id of Object.keys((args.update ?? {}) as Record<string, any>)) {
       notUpdated[id] = {
-        type: 'forbidden',
-        description: 'EmailSubmission updates are not supported.',
+        type: "forbidden",
+        description: "EmailSubmission updates are not supported.",
       };
     }
     for (const id of (args.destroy ?? []) as string[]) {
       notDestroyed[id] = {
-        type: 'forbidden',
-        description: 'EmailSubmission destroys are not supported.',
+        type: "forbidden",
+        description: "EmailSubmission destroys are not supported.",
       };
     }
 
-    const responses: Array<{ name: string; result: Record<string, any>; mutated?: boolean }> = [
+    const responses: Array<
+      { name: string; result: Record<string, any>; mutated?: boolean }
+    > = [
       {
-        name: 'EmailSubmission/set',
+        name: "EmailSubmission/set",
         result: {
           accountId: account.accountId,
           oldState: null,
-          newState: '0',
+          newState: "0",
           created,
           notCreated,
           updated: {},
@@ -1325,8 +1688,10 @@ export class JmapServer {
     // onSuccessUpdateEmail / onSuccessDestroyEmail (RFC 8621 §7.5): apply an
     // implicit Email/set for successfully created submissions and append its
     // response after the EmailSubmission/set response.
-    const resolveSubmissionRef = (reference: string): { submissionId: string; emailId: string } | null => {
-      if (reference.startsWith('#')) {
+    const resolveSubmissionRef = (
+      reference: string,
+    ): { submissionId: string; emailId: string } | null => {
+      if (reference.startsWith("#")) {
         return createdSubmissions.get(reference.slice(1)) ?? null;
       }
       for (const entry of createdSubmissions.values()) {
@@ -1338,11 +1703,15 @@ export class JmapServer {
     };
     const implicitSet: Record<string, any> = { accountId: account.accountId };
     let hasImplicitSet = false;
-    if (args.onSuccessUpdateEmail && typeof args.onSuccessUpdateEmail === 'object') {
+    if (
+      args.onSuccessUpdateEmail && typeof args.onSuccessUpdateEmail === "object"
+    ) {
       const update: Record<string, any> = {};
-      for (const [reference, patch] of Object.entries(
-        args.onSuccessUpdateEmail as Record<string, any>
-      )) {
+      for (
+        const [reference, patch] of Object.entries(
+          args.onSuccessUpdateEmail as Record<string, any>,
+        )
+      ) {
         const entry = resolveSubmissionRef(reference);
         if (entry) {
           update[entry.emailId] = patch;
@@ -1363,9 +1732,13 @@ export class JmapServer {
       implicitSet.destroy = destroy;
     }
     if (hasImplicitSet) {
-      const result = await this.methodEmailSet(account, implicitSet, createdIds);
+      const result = await this.methodEmailSet(
+        account,
+        implicitSet,
+        createdIds,
+      );
       responses.push({
-        name: 'Email/set',
+        name: "Email/set",
         result,
         mutated: result.newState !== result.oldState,
       });
@@ -1377,18 +1750,18 @@ export class JmapServer {
   private resolveEnvelope(
     specEnvelope: any,
     identityEmail: string,
-    email: IJmapEmailRecord
+    email: IJmapEmailRecord,
   ): IJmapEnvelope {
     if (
       specEnvelope &&
-      typeof specEnvelope === 'object' &&
+      typeof specEnvelope === "object" &&
       specEnvelope.mailFrom?.email &&
       Array.isArray(specEnvelope.rcptTo)
     ) {
       return {
         mailFrom: { email: String(specEnvelope.mailFrom.email) },
         rcptTo: specEnvelope.rcptTo
-          .filter((recipient: any) => typeof recipient?.email === 'string')
+          .filter((recipient: any) => typeof recipient?.email === "string")
           .map((recipient: any) => ({ email: recipient.email })),
       };
     }
@@ -1408,53 +1781,409 @@ export class JmapServer {
   // upload + download
   // ======================
 
+  private async cancelRequestBody(
+    request: Request,
+    reason: string,
+  ): Promise<void> {
+    try {
+      if (request.body && !request.body.locked) {
+        await request.body.cancel(reason);
+      }
+    } catch {
+      // The runtime or peer may already have closed the transport stream.
+    }
+  }
+
+  private async readRequestBodyBounded(
+    request: Request,
+    maxBytes: number,
+  ): Promise<Uint8Array> {
+    const declaredLength = request.headers.get("content-length");
+    if (declaredLength !== null) {
+      if (
+        !/^\d+$/.test(declaredLength) ||
+        !Number.isSafeInteger(Number(declaredLength))
+      ) {
+        await this.cancelRequestBody(request, "invalid content length");
+        throw new JmapRequestBodyError("invalidLength");
+      }
+      if (Number(declaredLength) > maxBytes) {
+        await this.cancelRequestBody(request, "request body too large");
+        throw new JmapRequestBodyError("tooLarge");
+      }
+    }
+    if (!request.body) {
+      return new Uint8Array();
+    }
+
+    const reader = request.body.getReader();
+    const chunks: Uint8Array[] = [];
+    let total = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        total += value.byteLength;
+        if (total > maxBytes) {
+          await reader.cancel("request body too large");
+          throw new JmapRequestBodyError("tooLarge");
+        }
+        chunks.push(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+
+    const data = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      data.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return data;
+  }
+
+  private createExactUploadBody(
+    request: Request,
+    expectedSize: number,
+  ): {
+    stream: ReadableStream<Uint8Array>;
+    signal: AbortSignal;
+    isComplete(): boolean;
+    cancel(reason: unknown): Promise<void>;
+    dispose(): void;
+  } {
+    const abortController = new AbortController();
+    let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
+    let bytesRead = 0;
+    let complete = false;
+    let cancelled = false;
+
+    const cancel = async (reason: unknown): Promise<void> => {
+      if (cancelled || complete) return;
+      cancelled = true;
+      abortController.abort(reason);
+      try {
+        if (reader) {
+          await reader.cancel(reason);
+        } else if (request.body && !request.body.locked) {
+          await request.body.cancel(reason);
+        }
+      } catch {
+        // The peer or consumer may already have closed the stream.
+      }
+    };
+    const onRequestAbort = (): void => {
+      void cancel(request.signal.reason ?? new Error("Request aborted."));
+    };
+    request.signal.addEventListener("abort", onRequestAbort, { once: true });
+    if (request.signal.aborted) onRequestAbort();
+
+    const stream = new ReadableStream<Uint8Array>({
+      async pull(controller) {
+        if (cancelled) {
+          controller.error(
+            abortController.signal.reason ?? new Error("Upload cancelled."),
+          );
+          return;
+        }
+        if (!request.body) {
+          if (expectedSize === 0) {
+            complete = true;
+            controller.close();
+          } else {
+            const error = new JmapRequestBodyError("lengthMismatch");
+            abortController.abort(error);
+            controller.error(error);
+          }
+          return;
+        }
+        reader ??= request.body.getReader();
+        const { done, value } = await reader.read();
+        if (done) {
+          if (bytesRead !== expectedSize) {
+            const error = new JmapRequestBodyError("lengthMismatch");
+            abortController.abort(error);
+            controller.error(error);
+            return;
+          }
+          complete = true;
+          controller.close();
+          return;
+        }
+        bytesRead += value.byteLength;
+        if (bytesRead > expectedSize) {
+          const error = new JmapRequestBodyError("lengthMismatch");
+          await cancel(error);
+          controller.error(error);
+          return;
+        }
+        controller.enqueue(value);
+      },
+      cancel,
+    }, { highWaterMark: 0 });
+
+    return {
+      stream,
+      signal: abortController.signal,
+      isComplete: () => complete,
+      cancel,
+      dispose: () =>
+        request.signal.removeEventListener("abort", onRequestAbort),
+    };
+  }
+
+  private mappedUploadErrorResponse(error: unknown): Response | null {
+    const problem = this.options.mapUploadError?.(error);
+    if (!problem) return null;
+    if (
+      !Number.isInteger(problem.status) || problem.status < 400 ||
+      problem.status > 599 ||
+      !problem.detail
+    ) {
+      throw new Error("mapUploadError returned an invalid upload problem.");
+    }
+    const body = {
+      type: problem.type ?? "about:blank",
+      status: problem.status,
+      detail: problem.detail,
+      ...(problem.limit ? { limit: problem.limit } : {}),
+    };
+    const headers: Record<string, string> = {
+      "content-type": "application/problem+json",
+    };
+    if (problem.retryAfterSeconds !== undefined) {
+      headers["retry-after"] = String(problem.retryAfterSeconds);
+    }
+    return new Response(JSON.stringify(body), {
+      status: problem.status,
+      headers,
+    });
+  }
+
+  private requestBodyErrorResponse(
+    error: JmapRequestBodyError,
+    limit: string,
+  ): Response {
+    if (error.reason === "invalidLength") {
+      return this.problemResponse(
+        400,
+        "about:blank",
+        "Invalid Content-Length header.",
+      );
+    }
+    if (error.reason === "lengthMismatch") {
+      return this.problemResponse(
+        400,
+        "about:blank",
+        "The request body does not match Content-Length.",
+      );
+    }
+    const maximum = limit === "maxSizeUpload"
+      ? this.limits.maxSizeUpload
+      : this.limits.maxSizeRequest;
+    return this.limitResponse(
+      400,
+      limit,
+      `The request is larger than ${maximum} bytes.`,
+    );
+  }
+
+  private async handleStreamingUpload(
+    account: IJmapAccountInfo,
+    request: Request,
+    type: string,
+  ): Promise<Response> {
+    const contentLength = request.headers.get("content-length");
+    if (contentLength === null) {
+      await this.cancelRequestBody(request, "content length required");
+      return this.problemResponse(
+        411,
+        "about:blank",
+        "Content-Length is required.",
+      );
+    }
+    if (
+      !/^\d+$/.test(contentLength) ||
+      !Number.isSafeInteger(Number(contentLength))
+    ) {
+      await this.cancelRequestBody(request, "invalid content length");
+      return this.problemResponse(
+        400,
+        "about:blank",
+        "Invalid Content-Length header.",
+      );
+    }
+    const declaredSize = Number(contentLength);
+    if (declaredSize > this.limits.maxSizeUpload) {
+      await this.cancelRequestBody(request, "request body too large");
+      return this.limitResponse(
+        400,
+        "maxSizeUpload",
+        `The upload is larger than ${this.limits.maxSizeUpload} bytes.`,
+      );
+    }
+    if (!request.body && declaredSize !== 0) {
+      return this.problemResponse(
+        400,
+        "about:blank",
+        "The request body does not match Content-Length.",
+      );
+    }
+
+    const body = this.createExactUploadBody(request, declaredSize);
+    const upload: IJmapBlobUploadStream = {
+      stream: body.stream,
+      size: declaredSize,
+      type,
+      signal: body.signal,
+    };
+    try {
+      const result = await this.backend.uploadBlobStream!(
+        account.accountId,
+        upload,
+      );
+      if (!body.isComplete()) {
+        await body.cancel(new JmapRequestBodyError("lengthMismatch"));
+        return this.problemResponse(
+          400,
+          "about:blank",
+          "The upload backend did not consume the exact request body.",
+        );
+      }
+      if (result.size !== declaredSize) {
+        throw new Error(
+          `Upload backend reported ${result.size} bytes for a ${declaredSize}-byte request.`,
+        );
+      }
+      return this.jsonResponse(200, {
+        accountId: account.accountId,
+        blobId: result.blobId,
+        type,
+        size: result.size,
+      });
+    } catch (error) {
+      await body.cancel(error);
+      if (error instanceof JmapRequestBodyError) {
+        return this.requestBodyErrorResponse(error, "maxSizeUpload");
+      }
+      const mapped = this.mappedUploadErrorResponse(error);
+      if (mapped) return mapped;
+      throw error;
+    } finally {
+      body.dispose();
+    }
+  }
+
   private async handleUpload(
     account: IJmapAccountInfo,
+    principal: TJmapPrincipal,
     pathname: string,
-    request: Request
+    request: Request,
   ): Promise<Response> {
-    const segments = pathname.split('/').filter((segment) => segment.length > 0);
-    const accountId = decodeURIComponent(segments[2] ?? '');
+    const segments = pathname.split("/").filter((segment) =>
+      segment.length > 0
+    );
+    const accountId = decodeURIComponent(segments[2] ?? "");
     if (accountId !== account.accountId) {
-      return this.problemResponse(404, 'about:blank', 'Unknown account');
+      await this.cancelRequestBody(request, "unknown account");
+      return this.problemResponse(404, "about:blank", "Unknown account");
     }
-    const data = new Uint8Array(await request.arrayBuffer());
-    if (data.length > JMAP_SERVER_LIMITS.maxSizeUpload) {
+
+    const principalUploads =
+      this.activeUploadsByPrincipal.get(principal.username) ?? 0;
+    if (
+      principalUploads >= this.limits.maxConcurrentUpload ||
+      this.activeUploadRequests >= this.maxConcurrentUploadServer
+    ) {
+      await this.cancelRequestBody(request, "upload concurrency limit reached");
       return this.limitResponse(
-        400,
-        'maxSizeUpload',
-        `The upload is larger than ${JMAP_SERVER_LIMITS.maxSizeUpload} bytes.`
+        429,
+        "maxConcurrentUpload",
+        "Too many concurrent uploads.",
       );
     }
-    const type = request.headers.get('content-type') ?? 'application/octet-stream';
-    const { blobId, size } = await this.backend.uploadBlob(account.accountId, data, type);
-    return this.jsonResponse(200, { accountId: account.accountId, blobId, type, size });
+
+    this.activeUploadRequests++;
+    this.activeUploadsByPrincipal.set(principal.username, principalUploads + 1);
+    try {
+      const type = request.headers.get("content-type") ??
+        "application/octet-stream";
+      if (typeof this.backend.uploadBlobStream === "function") {
+        return await this.handleStreamingUpload(account, request, type);
+      }
+      let data: Uint8Array;
+      try {
+        data = await this.readRequestBodyBounded(
+          request,
+          this.limits.maxSizeUpload,
+        );
+      } catch (error) {
+        if (error instanceof JmapRequestBodyError) {
+          return this.requestBodyErrorResponse(error, "maxSizeUpload");
+        }
+        throw error;
+      }
+      try {
+        const { blobId, size } = await this.backend.uploadBlob(
+          account.accountId,
+          data,
+          type,
+        );
+        return this.jsonResponse(200, {
+          accountId: account.accountId,
+          blobId,
+          type,
+          size,
+        });
+      } catch (error) {
+        const mapped = this.mappedUploadErrorResponse(error);
+        if (mapped) return mapped;
+        throw error;
+      }
+    } finally {
+      this.activeUploadRequests--;
+      const remainingPrincipalUploads =
+        (this.activeUploadsByPrincipal.get(principal.username) ?? 1) - 1;
+      if (remainingPrincipalUploads <= 0) {
+        this.activeUploadsByPrincipal.delete(principal.username);
+      } else {
+        this.activeUploadsByPrincipal.set(
+          principal.username,
+          remainingPrincipalUploads,
+        );
+      }
+    }
   }
 
   private async handleDownload(
     account: IJmapAccountInfo,
     pathname: string,
-    url: URL
+    url: URL,
   ): Promise<Response> {
     // /jmap/download/{accountId}/{blobId}/{name}
-    const segments = pathname.split('/').filter((segment) => segment.length > 0);
-    const accountId = decodeURIComponent(segments[2] ?? '');
-    const blobId = decodeURIComponent(segments[3] ?? '');
-    const name = decodeURIComponent(segments[4] ?? 'blob');
+    const segments = pathname.split("/").filter((segment) =>
+      segment.length > 0
+    );
+    const accountId = decodeURIComponent(segments[2] ?? "");
+    const blobId = decodeURIComponent(segments[3] ?? "");
+    const name = decodeURIComponent(segments[4] ?? "blob");
     if (accountId !== account.accountId) {
-      return this.problemResponse(404, 'about:blank', 'Unknown account');
+      return this.problemResponse(404, "about:blank", "Unknown account");
     }
     const blob = await this.backend.getBlob(account.accountId, blobId);
     if (!blob) {
-      return this.problemResponse(404, 'about:blank', 'Unknown blob');
+      return this.problemResponse(404, "about:blank", "Unknown blob");
     }
-    const type = url.searchParams.get('type') ?? blob.type;
+    const type = url.searchParams.get("type") ?? blob.type;
     return new Response(asBodyBytes(blob.data), {
       status: 200,
       headers: {
-        'content-type': type,
-        'content-length': String(blob.data.length),
-        'content-disposition': `attachment; filename="${name.replaceAll('"', '')}"`,
+        "content-type": type,
+        "content-length": String(blob.data.length),
+        "content-disposition": `attachment; filename="${
+          name.replaceAll('"', "")
+        }"`,
       },
     });
   }
@@ -1464,20 +2193,18 @@ export class JmapServer {
   // ======================
 
   private handleEventSource(account: IJmapAccountInfo, url: URL): Response {
-    const typesParam = url.searchParams.get('types') ?? '*';
-    const types =
-      typesParam === '*' || typesParam === ''
-        ? null
-        : new Set(
-            typesParam
-              .split(',')
-              .map((entry) => entry.trim())
-              .filter((entry) => entry.length > 0)
-          );
-    const closeAfterState = url.searchParams.get('closeafter') === 'state';
-    const pingRaw = Number(url.searchParams.get('ping') ?? '0');
-    const pingSeconds =
-      Number.isFinite(pingRaw) && pingRaw > 0 ? Math.max(1, Math.floor(pingRaw)) : 0;
+    const typesParam = url.searchParams.get("types") ?? "*";
+    const types = typesParam === "*" || typesParam === "" ? null : new Set(
+      typesParam
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0),
+    );
+    const closeAfterState = url.searchParams.get("closeafter") === "state";
+    const pingRaw = Number(url.searchParams.get("ping") ?? "0");
+    const pingSeconds = Number.isFinite(pingRaw) && pingRaw > 0
+      ? Math.max(1, Math.floor(pingRaw))
+      : 0;
 
     const state: IEventStreamState = {
       accountId: account.accountId,
@@ -1491,10 +2218,13 @@ export class JmapServer {
     const stream = new ReadableStream<Uint8Array>({
       start: (controller) => {
         state.controller = controller;
-        controller.enqueue(textEncoder.encode(': jmap event stream\n\n'));
+        controller.enqueue(textEncoder.encode(": jmap event stream\n\n"));
         if (pingSeconds > 0) {
           state.pingTimer = setInterval(() => {
-            this.writeToStream(state, `event: ping\ndata: {"interval":${pingSeconds}}\n\n`);
+            this.writeToStream(
+              state,
+              `event: ping\ndata: {"interval":${pingSeconds}}\n\n`,
+            );
           }, pingSeconds * 1000);
         }
         try {
@@ -1512,8 +2242,8 @@ export class JmapServer {
     return new Response(stream, {
       status: 200,
       headers: {
-        'content-type': 'text/event-stream',
-        'cache-control': 'no-cache',
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
       },
     });
   }
@@ -1535,8 +2265,13 @@ export class JmapServer {
     }
     this.eventStreams.delete(state);
     if (!this.eventStreams.size && this.changeFeedUnsubscribe) {
-      this.changeFeedUnsubscribe();
+      const unsubscribe = this.changeFeedUnsubscribe;
       this.changeFeedUnsubscribe = null;
+      try {
+        unsubscribe();
+      } catch (error) {
+        this.cleanupErrors.push(error);
+      }
     }
   }
 
@@ -1565,7 +2300,10 @@ export class JmapServer {
    * deduplicated per stream, so a mutation notified both by the backend
    * change feed and by the post-request push is delivered once.
    */
-  private pushStateChange(accountId: string, changed: Record<string, string>): void {
+  private pushStateChange(
+    accountId: string,
+    changed: Record<string, string>,
+  ): void {
     for (const state of Array.from(this.eventStreams)) {
       if (state.accountId !== accountId) {
         continue;
@@ -1587,10 +2325,13 @@ export class JmapServer {
         state.lastSent.set(type, typeState);
       }
       const stateChange = {
-        '@type': 'StateChange',
+        "@type": "StateChange",
         changed: { [accountId]: filtered },
       };
-      this.writeToStream(state, `event: state\ndata: ${JSON.stringify(stateChange)}\n\n`);
+      this.writeToStream(
+        state,
+        `event: state\ndata: ${JSON.stringify(stateChange)}\n\n`,
+      );
       if (state.closeAfterState) {
         this.closeStream(state);
       }
@@ -1622,62 +2363,126 @@ export class JmapServer {
   // node req/res adapter
   // ======================
 
+  private nodeRequestBody(
+    req: plugins.http.IncomingMessage,
+  ): ReadableStream<Uint8Array> {
+    let closed = false;
+    let cleanup = (): void => {};
+    return new ReadableStream<Uint8Array>({
+      start(controller) {
+        req.pause();
+        const onData = (chunk: Buffer): void => {
+          if (closed) return;
+          controller.enqueue(
+            new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength),
+          );
+          if ((controller.desiredSize ?? 0) <= 0) req.pause();
+        };
+        const onEnd = (): void => {
+          if (closed) return;
+          closed = true;
+          cleanup();
+          controller.close();
+        };
+        const onAborted = (): void => {
+          if (closed) return;
+          closed = true;
+          cleanup();
+          controller.error(new Error("Request body stream was aborted."));
+        };
+        const onError = (error: Error): void => {
+          if (closed) return;
+          closed = true;
+          cleanup();
+          controller.error(error);
+        };
+        cleanup = () => {
+          req.off("data", onData);
+          req.off("end", onEnd);
+          req.off("aborted", onAborted);
+          req.off("error", onError);
+        };
+        req.on("data", onData);
+        req.once("end", onEnd);
+        req.once("aborted", onAborted);
+        req.once("error", onError);
+      },
+      pull() {
+        if (!closed) req.resume();
+      },
+      cancel() {
+        if (closed) return;
+        closed = true;
+        cleanup();
+        // Drain without buffering so the response can reuse the connection.
+        req.resume();
+      },
+    });
+  }
+
   private async handleNodeRequest(
     req: plugins.http.IncomingMessage,
-    res: plugins.http.ServerResponse
+    res: plugins.http.ServerResponse,
+    requestAbortController: AbortController,
   ): Promise<void> {
-    try {
-      const method = (req.method ?? 'GET').toUpperCase();
-      let body: Uint8Array | undefined;
-      if (method !== 'GET' && method !== 'HEAD') {
-        const chunks: Buffer[] = [];
-        let total = 0;
-        // Cap request buffering at maxSizeUpload; larger requests never make
-        // it to fetchHandler (which enforces the JMAP per-endpoint limits).
-        const maxBuffered = JMAP_SERVER_LIMITS.maxSizeUpload + 1;
-        for await (const chunk of req) {
-          const buffer = chunk as Buffer;
-          total += buffer.length;
-          if (total > maxBuffered) {
-            res.writeHead(413, { 'content-type': 'application/problem+json' });
-            res.end(
-              JSON.stringify({
-                type: 'urn:ietf:params:jmap:error:limit',
-                limit: 'maxSizeUpload',
-                status: 413,
-                detail: 'Request body too large.',
-              })
-            );
-            req.destroy();
-            return;
-          }
-          chunks.push(buffer);
-        }
-        body = Buffer.concat(chunks);
+    const abortRequest = (reason: unknown): void => {
+      if (!requestAbortController.signal.aborted) {
+        requestAbortController.abort(reason);
       }
-
+    };
+    const onRequestAborted = (): void => {
+      abortRequest(new Error("Node request was aborted by the client."));
+    };
+    const onRequestError = (error: Error): void => {
+      abortRequest(error);
+    };
+    const onRequestClose = (): void => {
+      // IncomingMessage emits close after normal completion too. Only a
+      // close before the complete HTTP message is a transport abort.
+      if (!req.complete) onRequestAborted();
+    };
+    const onResponseClose = (): void => {
+      if (!res.writableEnded) {
+        abortRequest(
+          new Error("Node response connection closed before completion."),
+        );
+      }
+    };
+    req.once("aborted", onRequestAborted);
+    req.once("error", onRequestError);
+    req.once("close", onRequestClose);
+    res.once("close", onResponseClose);
+    try {
+      const method = (req.method ?? "GET").toUpperCase();
       const headers = new Headers();
       const skippedHeaders = new Set([
-        'connection',
-        'content-length',
-        'expect',
-        'keep-alive',
-        'proxy-connection',
-        'transfer-encoding',
-        'upgrade',
+        "connection",
+        "expect",
+        "keep-alive",
+        "proxy-connection",
+        "transfer-encoding",
+        "upgrade",
       ]);
       for (const [key, value] of Object.entries(req.headers)) {
         if (value === undefined || skippedHeaders.has(key.toLowerCase())) {
           continue;
         }
-        headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+        headers.set(key, Array.isArray(value) ? value.join(", ") : value);
       }
-      const host = req.headers.host ?? '127.0.0.1';
-      const request = new Request(`http://${host}${req.url ?? '/'}`, {
+      const host = req.headers.host ?? "127.0.0.1";
+      const requestInit: RequestInit & { duplex?: "half" } = {
         method,
         headers,
-        body: body ? asBodyBytes(body) : undefined,
-      });
+        signal: requestAbortController.signal,
+      };
+      if (method !== "GET" && method !== "HEAD") {
+        requestInit.body = this.nodeRequestBody(req);
+        requestInit.duplex = "half";
+      }
+      const request = new Request(
+        `http://${host}${req.url ?? "/"}`,
+        requestInit,
+      );
 
       const response = await this.fetchHandler(request);
 
@@ -1692,7 +2497,7 @@ export class JmapServer {
       }
       const reader = response.body.getReader();
       let clientClosed = false;
-      res.on('close', () => {
+      res.on("close", () => {
         clientClosed = true;
         // Cancelling the reader triggers the stream's cancel handler, which
         // releases any per-stream resources (SSE registration, ping timer).
@@ -1715,9 +2520,16 @@ export class JmapServer {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (!res.headersSent) {
-        res.writeHead(500, { 'content-type': 'application/problem+json' });
+        res.writeHead(500, { "content-type": "application/problem+json" });
       }
-      res.end(JSON.stringify({ type: 'about:blank', status: 500, detail: message }));
+      res.end(
+        JSON.stringify({ type: "about:blank", status: 500, detail: message }),
+      );
+    } finally {
+      req.off("aborted", onRequestAborted);
+      req.off("error", onRequestError);
+      req.off("close", onRequestClose);
+      res.off("close", onResponseClose);
     }
   }
 
@@ -1727,29 +2539,37 @@ export class JmapServer {
 
   private validateProperties(
     requested: any,
-    known: Set<string>
+    known: Set<string>,
   ): string[] | null {
     if (requested === null || requested === undefined) {
       return null;
     }
     if (!Array.isArray(requested)) {
-      throw new JmapServerMethodError('invalidArguments', 'properties must be an array or null.');
+      throw new JmapServerMethodError(
+        "invalidArguments",
+        "properties must be an array or null.",
+      );
     }
     for (const property of requested) {
-      if (typeof property !== 'string' || !known.has(property)) {
+      if (typeof property !== "string" || !known.has(property)) {
         throw new JmapServerMethodError(
-          'invalidArguments',
-          `Unknown property "${String(property)}".`
+          "invalidArguments",
+          `Unknown property "${String(property)}".`,
         );
       }
     }
-    return requested.includes('id') ? requested : ['id', ...requested];
+    return requested.includes("id") ? requested : ["id", ...requested];
   }
 
-  private projectObject(source: Record<string, any>, properties: string[]): Record<string, any> {
+  private projectObject(
+    source: Record<string, any>,
+    properties: string[],
+  ): Record<string, any> {
     const projected: Record<string, any> = {};
     for (const property of properties) {
-      projected[property] = source[property] === undefined ? null : source[property];
+      projected[property] = source[property] === undefined
+        ? null
+        : source[property];
     }
     return projected;
   }
@@ -1760,8 +2580,8 @@ export class JmapServer {
     }
     if (!Number.isInteger(args.position) || args.position < 0) {
       throw new JmapServerMethodError(
-        'invalidArguments',
-        'position must be a non-negative integer.'
+        "invalidArguments",
+        "position must be a non-negative integer.",
       );
     }
     return args.position as number;
@@ -1771,15 +2591,18 @@ export class JmapServer {
     sinceState: string;
     maxChanges?: number;
   } {
-    if (typeof args.sinceState !== 'string') {
-      throw new JmapServerMethodError('invalidArguments', 'sinceState is required.');
+    if (typeof args.sinceState !== "string") {
+      throw new JmapServerMethodError(
+        "invalidArguments",
+        "sinceState is required.",
+      );
     }
     let maxChanges: number | undefined;
     if (args.maxChanges !== undefined && args.maxChanges !== null) {
       if (!Number.isInteger(args.maxChanges) || args.maxChanges <= 0) {
         throw new JmapServerMethodError(
-          'invalidArguments',
-          'maxChanges must be a positive integer.'
+          "invalidArguments",
+          "maxChanges must be a positive integer.",
         );
       }
       maxChanges = args.maxChanges as number;
@@ -1790,7 +2613,7 @@ export class JmapServer {
   private jsonResponse(status: number, body: unknown): Response {
     return new Response(JSON.stringify(body), {
       status,
-      headers: { 'content-type': 'application/json' },
+      headers: { "content-type": "application/json" },
     });
   }
 
@@ -1798,18 +2621,27 @@ export class JmapServer {
     status: number,
     type: string,
     detail: string,
-    extraHeaders: Record<string, string> = {}
+    extraHeaders: Record<string, string> = {},
   ): Response {
     return new Response(JSON.stringify({ type, status, detail }), {
       status,
-      headers: { 'content-type': 'application/problem+json', ...extraHeaders },
+      headers: { "content-type": "application/problem+json", ...extraHeaders },
     });
   }
 
-  private limitResponse(status: number, limit: string, detail: string): Response {
+  private limitResponse(
+    status: number,
+    limit: string,
+    detail: string,
+  ): Response {
     return new Response(
-      JSON.stringify({ type: 'urn:ietf:params:jmap:error:limit', limit, status, detail }),
-      { status, headers: { 'content-type': 'application/problem+json' } }
+      JSON.stringify({
+        type: "urn:ietf:params:jmap:error:limit",
+        limit,
+        status,
+        detail,
+      }),
+      { status, headers: { "content-type": "application/problem+json" } },
     );
   }
 }