@dxos/plugin-jmap 0.10.0

package/dist/lib/chunk-send.mjs

@@ -0,0 +1,98 @@
+import { d as mailboxGet, f as submitEmail, h as JmapCredentials, m as getSession, u as identityGet } from "./chunk-apis.mjs";
+import { n as JmapSendIdentityNotFoundError, r as JmapSendMessageInvalidError, t as JmapApiError } from "./chunk-errors.mjs";
+import "./services.mjs";
+import * as Effect from "effect/Effect";
+import { log } from "@dxos/log";
+import * as Operation from "@dxos/compute/Operation";
+import * as InboxOperation from "@dxos/plugin-inbox/InboxOperation";
+import * as SystemTags from "@dxos/plugin-inbox/SystemTags";
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+//#region src/operations/mail/send/handler.ts
+var __dxlog_file = "/Users/burdon/Code/dxos/dxos/.claude/worktrees/confident-jones-b0b4bf/packages/plugins/plugin-jmap/src/operations/mail/send/handler.ts";
+var MAIL_ACCOUNT_CAPABILITY = "urn:ietf:params:jmap:mail";
+var handler_default = InboxOperation.JmapSend.pipe(Operation.withHandler(({ message, connection: connectionRef }) => Effect.gen(function* () {
+	log("sending email via jmap", { connection: connectionRef.uri }, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 22,
+		S: this
+	});
+	const to = message.properties?.to;
+	const cc = message.properties?.cc;
+	const bcc = message.properties?.bcc;
+	const subject = message.properties?.subject;
+	const inReplyTo = message.properties?.inReplyTo;
+	const references = message.properties?.references;
+	const textBlock = message.blocks.find((block) => block._tag === "text");
+	const text = textBlock?._tag === "text" ? textBlock.text : void 0;
+	if (!to || !text) return yield* Effect.fail(new JmapSendMessageInvalidError());
+	const session = yield* getSession;
+	const accountId = session.primaryAccounts[MAIL_ACCOUNT_CAPABILITY];
+	if (!accountId) return yield* Effect.fail(new JmapApiError(void 0, "JMAP session has no mail account."));
+	const target = {
+		apiUrl: session.apiUrl,
+		accountId
+	};
+	const account = (yield* JmapCredentials).account ?? session.username;
+	const { list: identities } = yield* identityGet(target);
+	const identity = account ? identities.find((candidate) => candidate.email.toLowerCase() === account.toLowerCase()) : identities[0];
+	if (!identity) return yield* Effect.fail(new JmapSendIdentityNotFoundError(account));
+	const { list: folders } = yield* mailboxGet(target);
+	const drafts = folders.find((folder) => folder.role === "drafts");
+	const sent = folders.find((folder) => folder.role === "sent");
+	if (!drafts || !sent) return yield* Effect.fail(new JmapApiError(void 0, "JMAP account is missing a Drafts or Sent folder."));
+	const fromAddress = identity.name ? {
+		email: identity.email,
+		name: identity.name
+	} : { email: identity.email };
+	const result = yield* submitEmail(target, {
+		identityId: identity.id,
+		draftsMailboxId: drafts.id,
+		sentMailboxId: sent.id,
+		draft: {
+			from: [fromAddress],
+			to: parseAddressList(to),
+			...cc ? { cc: parseAddressList(cc) } : {},
+			...bcc ? { bcc: parseAddressList(bcc) } : {},
+			...subject ? { subject } : {},
+			...inReplyTo ? { inReplyTo: [inReplyTo] } : {},
+			...references ? { references: splitReferences(references) } : {},
+			text
+		}
+	});
+	log("email sent via jmap", { id: result.id }, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 82,
+		S: this
+	});
+	return {
+		id: result.id,
+		threadId: result.threadId ?? "",
+		sentTag: {
+			...SystemTags.systemTagKey("sent"),
+			label: SystemTags.SystemTag.sent.label
+		}
+	};
+}).pipe(Effect.provide(FetchHttpClient.layer), Effect.provide(JmapCredentials.fromConnection(connectionRef)))), Operation.opaqueHandler);
+/** Parses a comma-separated header value into JMAP structured addresses. */
+var parseAddressList = (value) => value.split(",").map((part) => part.trim()).filter(Boolean).map(parseAddress);
+/** Parses a single `"Name <email>"` (or bare `email`) into a JMAP structured address. */
+var parseAddress = (value) => {
+	const match = value.match(/^\s*(?:"?([^"<]*?)"?\s+)?<([^>]+)>\s*$/);
+	if (match) {
+		const name = match[1]?.trim();
+		const email = match[2].trim();
+		return name ? {
+			email,
+			name
+		} : { email };
+	}
+	return { email: value.trim() };
+};
+/** Splits a `References` header (whitespace-separated message ids) into an array. */
+var splitReferences = (value) => value.split(/\s+/).filter(Boolean);
+//#endregion
+export { handler_default as default };
+
+//# sourceMappingURL=chunk-send.mjs.map

package/dist/lib/chunk-send.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-send.mjs","names":[],"sources":["../../src/operations/mail/send/handler.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as FetchHttpClient from '@effect/platform/FetchHttpClient';\nimport * as Effect from 'effect/Effect';\n\nimport * as Operation from '@dxos/compute/Operation';\nimport { log } from '@dxos/log';\nimport * as InboxOperation from '@dxos/plugin-inbox/InboxOperation';\nimport * as SystemTags from '@dxos/plugin-inbox/SystemTags';\n\nimport { Jmap, JmapMail } from '../../../apis';\nimport { JmapApiError, JmapSendIdentityNotFoundError, JmapSendMessageInvalidError } from '../../../errors';\nimport { JmapCredentials } from '../../../services';\n\nconst MAIL_ACCOUNT_CAPABILITY = 'urn:ietf:params:jmap:mail';\n\nexport default InboxOperation.JmapSend.pipe(\n  Operation.withHandler(({ message, connection: connectionRef }) =>\n    Effect.gen(function* () {\n      log('sending email via jmap', { connection: connectionRef.uri });\n\n      const to = message.properties?.to;\n      const cc = message.properties?.cc;\n      const bcc = message.properties?.bcc;\n      const subject = message.properties?.subject;\n      const inReplyTo = message.properties?.inReplyTo;\n      const references = message.properties?.references;\n      const textBlock = message.blocks.find((block) => block._tag === 'text');\n      const text = textBlock?._tag === 'text' ? textBlock.text : undefined;\n\n      if (!to || !text) {\n        return yield* Effect.fail(new JmapSendMessageInvalidError());\n      }\n\n      const session = yield* Jmap.getSession;\n      const accountId = session.primaryAccounts[MAIL_ACCOUNT_CAPABILITY];\n      if (!accountId) {\n        return yield* Effect.fail(new JmapApiError(undefined, 'JMAP session has no mail account.'));\n      }\n      const target: JmapMail.Target = { apiUrl: session.apiUrl, accountId };\n\n      const credentials = yield* JmapCredentials;\n      const account = credentials.account ?? session.username;\n\n      // The submission requires an identity whose email the server permits as `from`; pick the one\n      // matching the connection account (fall back to the first if the account is unknown).\n      const { list: identities } = yield* JmapMail.identityGet(target);\n      const identity = account\n        ? identities.find((candidate) => candidate.email.toLowerCase() === account.toLowerCase())\n        : identities[0];\n      if (!identity) {\n        return yield* Effect.fail(new JmapSendIdentityNotFoundError(account));\n      }\n\n      const { list: folders } = yield* JmapMail.mailboxGet(target);\n      const drafts = folders.find((folder) => folder.role === 'drafts');\n      const sent = folders.find((folder) => folder.role === 'sent');\n      if (!drafts || !sent) {\n        return yield* Effect.fail(new JmapApiError(undefined, 'JMAP account is missing a Drafts or Sent folder.'));\n      }\n\n      const fromAddress = identity.name ? { email: identity.email, name: identity.name } : { email: identity.email };\n\n      const result = yield* JmapMail.submitEmail(target, {\n        identityId: identity.id,\n        draftsMailboxId: drafts.id,\n        sentMailboxId: sent.id,\n        draft: {\n          from: [fromAddress],\n          to: parseAddressList(to),\n          ...(cc ? { cc: parseAddressList(cc) } : {}),\n          ...(bcc ? { bcc: parseAddressList(bcc) } : {}),\n          ...(subject ? { subject } : {}),\n          ...(inReplyTo ? { inReplyTo: [inReplyTo] } : {}),\n          ...(references ? { references: splitReferences(references) } : {}),\n          text,\n        },\n      });\n\n      log('email sent via jmap', { id: result.id });\n      return {\n        id: result.id,\n        threadId: result.threadId ?? '',\n        // The submission filed the message into the Sent (`sent`-role) folder, which sync maps onto the\n        // canonical `sent` system tag; return that same canonical tag so the caller can tag the local\n        // draft to match the copy that will sync down.\n        sentTag: { ...SystemTags.systemTagKey('sent'), label: SystemTags.SystemTag.sent.label },\n      };\n    }).pipe(Effect.provide(FetchHttpClient.layer), Effect.provide(JmapCredentials.fromConnection(connectionRef))),\n  ),\n  Operation.opaqueHandler,\n);\n\n/** Parses a comma-separated header value into JMAP structured addresses. */\nconst parseAddressList = (value: string): { email: string; name?: string }[] =>\n  value\n    .split(',')\n    .map((part) => part.trim())\n    .filter(Boolean)\n    .map(parseAddress);\n\n/** Parses a single `\"Name <email>\"` (or bare `email`) into a JMAP structured address. */\nconst parseAddress = (value: string): { email: string; name?: string } => {\n  const match = value.match(/^\\s*(?:\"?([^\"<]*?)\"?\\s+)?<([^>]+)>\\s*$/);\n  if (match) {\n    const name = match[1]?.trim();\n    const email = match[2].trim();\n    return name ? { email, name } : { email };\n  }\n  return { email: value.trim() };\n};\n\n/** Splits a `References` header (whitespace-separated message ids) into an array. */\nconst splitReferences = (value: string): string[] => value.split(/\\s+/).filter(Boolean);\n"],"mappings":"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"}

package/dist/lib/chunk-sync-provider.mjs

@@ -0,0 +1,511 @@
+import { i as resolveMailboxByNameOrRole, n as filterScopesMailbox, r as parseMailQuery } from "./chunk-apis.mjs";
+import { n as JMAP_DOMAIN } from "./chunk-constants.mjs";
+import { JmapMailApi } from "./services.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { Obj, Ref, Tag } from "@dxos/echo";
+import { log } from "@dxos/log";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import { MailSyncError, MailSyncProvider } from "@dxos/plugin-inbox/sync";
+import * as Chunk from "effect/Chunk";
+import * as Stream from "effect/Stream";
+import { resolve } from "@dxos/extractor";
+import { Cursor } from "@dxos/link";
+import { Stage } from "@dxos/pipeline";
+import * as Mailbox from "@dxos/plugin-inbox/Mailbox";
+import * as SystemTags from "@dxos/plugin-inbox/SystemTags";
+import { TagIndex } from "@dxos/schema";
+import { Message, Person } from "@dxos/types";
+//#region src/operations/mail/mapper.ts
+var __dxlog_file$1 = "/Users/burdon/Code/dxos/dxos/.claude/worktrees/confident-jones-b0b4bf/packages/plugins/plugin-jmap/src/operations/mail/mapper.ts";
+/** Attachment parts carry a `blobId` to fetch bytes for; parts without one can't be downloaded. */
+var collectAttachments = (attachments) => (attachments ?? []).flatMap((part) => part.blobId ? [{
+	blobId: part.blobId,
+	name: part.name ?? void 0,
+	mimeType: part.type,
+	size: part.size,
+	contentId: part.cid ? part.cid.replace(/^<|>$/g, "") : void 0
+}] : []);
+/**
+* Extracts the raw HTML and plaintext bodies from a JMAP email (values fetched via
+* `fetchHTMLBodyValues`/`fetchTextBodyValues`). Returns `null` when the email has neither. No
+* HTML→markdown conversion — the markdown/plain views derive from these raw blocks in the component.
+*/
+var decodeBody = (email) => {
+	const html = getBodyValue(email, email.htmlBody);
+	const plain = getBodyValue(email, email.textBody);
+	if (html === void 0 && plain === void 0) {
+		log("jmap decodeBody: dropping email with no extractable body", {
+			id: email.id,
+			htmlBodyParts: email.htmlBody?.length ?? 0,
+			textBodyParts: email.textBody?.length ?? 0,
+			bodyValues: email.bodyValues ? Object.keys(email.bodyValues).length : 0
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 72,
+			S: void 0
+		});
+		return null;
+	}
+	return {
+		raw: email,
+		html,
+		plain,
+		attachments: collectAttachments(email.attachments)
+	};
+};
+/**
+* Builds an ECHO Message from a decoded (already body-normalized) JMAP email and an optional resolved
+* sender contact. Pure — contact resolution is done by the caller. Returns `null` when the email has
+* no sender.
+*/
+var mapToMessage = (decoded, contact) => {
+	const { raw: email, html, plain } = decoded;
+	const fromAddress = email.from?.[0];
+	if (!fromAddress) {
+		log("jmap mapToMessage: dropping email with no sender", { id: email.id }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 92,
+			S: void 0
+		});
+		return null;
+	}
+	const sender = {
+		email: fromAddress.email,
+		...fromAddress.name ? { name: fromAddress.name } : {},
+		...contact ? { contact: Ref.make(contact) } : {}
+	};
+	const blocks = [];
+	if (html !== void 0) blocks.push({
+		_tag: "text",
+		text: html,
+		mimeType: "text/html"
+	});
+	if (plain !== void 0) blocks.push({
+		_tag: "text",
+		text: plain,
+		mimeType: "text/plain"
+	});
+	const echoMessage = Obj.make(Message.Message, {
+		[Obj.Meta]: { keys: [{
+			id: email.id,
+			source: JMAP_DOMAIN
+		}] },
+		created: email.receivedAt,
+		sender,
+		threadId: email.threadId,
+		properties: {
+			threadId: email.threadId,
+			snippet: email.preview ?? void 0,
+			subject: email.subject ?? void 0,
+			messageId: email.messageId?.[0],
+			inReplyTo: email.inReplyTo?.[0],
+			references: email.references?.join(" "),
+			to: formatAddresses(email.to),
+			cc: formatAddresses(email.cc)
+		},
+		blocks
+	});
+	const keywords = email.keywords ? Object.entries(email.keywords).filter(([, set]) => set).map(([keyword]) => keyword) : [];
+	return {
+		message: echoMessage,
+		mailboxIds: email.mailboxIds ? Object.keys(email.mailboxIds) : [],
+		keywords
+	};
+};
+Effect.fnUntraced(function* (email) {
+	const decoded = decodeBody(email);
+	if (!decoded) return null;
+	const fromAddress = email.from?.[0];
+	return mapToMessage(decoded, (fromAddress ? yield* resolve(Person.Person, { email: fromAddress.email }) : void 0) ?? void 0);
+});
+/** Formats a JMAP address as `"Name <email>"`, or just the address when unnamed. */
+var formatAddress = (address) => address.name ? `${address.name} <${address.email}>` : address.email;
+/** Joins an address list into a header-style string, or `undefined` when empty. */
+var formatAddresses = (addresses) => addresses && addresses.length > 0 ? addresses.map(formatAddress).join(", ") : void 0;
+/**
+* Returns the first non-empty decoded value among the given body parts (e.g. `email.htmlBody` or
+* `email.textBody`). `Email/get` is requested with `fetchHTMLBodyValues`/`fetchTextBodyValues`, so the
+* referenced `bodyValues` are already decoded.
+*/
+var getBodyValue = (email, parts) => {
+	for (const part of parts ?? []) {
+		const value = part.partId ? email.bodyValues?.[part.partId]?.value : void 0;
+		if (value && value.trim().length > 0) return value;
+	}
+};
+//#endregion
+//#region src/operations/mail/tags.ts
+/**
+* The pre-rename source, matched as a fallback so folders synced before the rename keep their tag
+* identity instead of being duplicated. Remove one release after landing.
+*/
+var LEGACY_JMAP_TAG_SOURCE = "org.ietf.jmap.mailbox";
+/**
+* Finds an existing JMAP provider {@link Tag} object by its JMAP mailbox-id foreign key, or creates one
+* carrying that key ({@link JMAP_DOMAIN}, which also marks it read-only via `Tag.isProviderTag`). Keeps
+* the folder label in sync with the server on re-sync. Used by `sync/` for custom user folders;
+* well-known roles map onto canonical system tags instead. Mirrors Gmail's `findOrCreateGmailTag`.
+*/
+var findOrCreateJmapTag = (db, { id, name }) => Tag.findOrCreate(db, {
+	key: {
+		source: JMAP_DOMAIN,
+		id
+	},
+	legacyKeys: [{
+		source: LEGACY_JMAP_TAG_SOURCE,
+		id
+	}],
+	label: name
+});
+//#endregion
+//#region src/operations/mail/sync/system-tags.ts
+/**
+* JMAP mailbox role → canonical system tag ({@link SystemTags.SystemTag}). Roles absent here are
+* intentionally dropped: `archive` is derived as "not in inbox" (Gmail's model), and
+* `drafts`/`trash`/`junk` are never synced.
+*/
+var JMAP_ROLE_TAGS = {
+	inbox: "inbox",
+	sent: "sent"
+};
+/**
+* JMAP keyword → canonical system tag ({@link SystemTags.SystemTag}). Only `$flagged` (starred) is
+* projected; read-state (`$seen`) and the rest (`$answered`, `$draft`, `$forwarded`, …) are intentionally
+* dropped as high-churn and noisier than useful.
+*/
+var JMAP_KEYWORD_TAGS = { $flagged: "starred" };
+//#endregion
+//#region src/operations/mail/sync/sync-provider.ts
+var __dxlog_file = "/Users/burdon/Code/dxos/dxos/.claude/worktrees/confident-jones-b0b4bf/packages/plugins/plugin-jmap/src/operations/mail/sync/sync-provider.ts";
+var MAIL_ACCOUNT_CAPABILITY = "urn:ietf:params:jmap:mail";
+/** JMAP mail's streaming-pipeline tuning; see {@link SyncStreamConfig.SyncStreamConfig}. */
+var JMAP_SYNC_CONFIG = {
+	listPageSize: 50,
+	fetchConcurrency: 5,
+	commitPageSize: 10,
+	maxItemsPerRun: 500
+};
+/**
+* JMAP's {@link MailSyncProvider}: session/account discovery, the email source, the folder→tag map, and
+* the fused decode+map. Captures {@link JmapMailApi} + {@link Resolver} so the harness never names them.
+* Mirror of the Gmail provider (`googleMailSyncProvider`).
+*/
+var jmapMailSyncProvider = () => Layer.effect(MailSyncProvider, Effect.gen(function* () {
+	const context = yield* Effect.context();
+	const providerApi = yield* JmapMailApi;
+	return {
+		name: "jmap",
+		config: JMAP_SYNC_CONFIG,
+		foreignKeySource: JMAP_DOMAIN,
+		prepare: ({ db, binding, now, token, maxMessages }) => Effect.gen(function* () {
+			const api = yield* JmapMailApi;
+			const session = yield* api.getSession;
+			const accountId = session.primaryAccounts[MAIL_ACCOUNT_CAPABILITY];
+			if (!accountId) {
+				log.warn("jmap sync: session has no mail account", { username: session.username }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 73,
+					S: this
+				});
+				return;
+			}
+			const target = {
+				apiUrl: session.apiUrl,
+				accountId,
+				downloadUrl: session.downloadUrl
+			};
+			log("jmap sync: session resolved", {
+				apiUrl: session.apiUrl,
+				accountId
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 77,
+				S: this
+			});
+			const { list: folders } = yield* api.mailboxGet(target);
+			const folderTagMap = /* @__PURE__ */ new Map();
+			for (const folder of folders) {
+				const canonical = folder.role ? JMAP_ROLE_TAGS[folder.role] : void 0;
+				if (canonical) {
+					const tag = yield* Effect.promise(() => SystemTags.findOrCreateSystemTag(db, canonical));
+					folderTagMap.set(folder.id, Mailbox.tagUri(tag));
+				} else if (folder.role) continue;
+				else {
+					const tag = yield* Effect.promise(() => findOrCreateJmapTag(db, {
+						id: folder.id,
+						name: folder.name
+					}));
+					folderTagMap.set(folder.id, Mailbox.tagUri(tag));
+				}
+			}
+			const keywordTagMap = /* @__PURE__ */ new Map();
+			for (const [keyword, canonical] of Object.entries(JMAP_KEYWORD_TAGS)) {
+				if (!canonical) continue;
+				const tag = yield* Effect.promise(() => SystemTags.findOrCreateSystemTag(db, canonical));
+				keywordTagMap.set(keyword, Mailbox.tagUri(tag));
+			}
+			const toMapped = (email) => Effect.gen(function* () {
+				const decoded = decodeBody(email);
+				if (!decoded) return;
+				const fromAddress = decoded.raw.from?.[0];
+				const mapped = mapToMessage(decoded, (fromAddress ? yield* resolve(Person.Person, { email: fromAddress.email }) : void 0) ?? void 0);
+				if (!mapped) return;
+				const folderUris = mapped.mailboxIds.flatMap((folderId) => {
+					const uri = folderTagMap.get(folderId);
+					return uri ? [uri] : [];
+				});
+				const keywordUris = mapped.keywords.flatMap((keyword) => {
+					const uri = keywordTagMap.get(keyword);
+					return uri ? [uri] : [];
+				});
+				const tagUris = [...folderUris, ...keywordUris];
+				const attachments = yield* fetchAttachments(target, decoded.attachments);
+				return {
+					_tag: "insert",
+					message: mapped.message,
+					foreignId: decoded.raw.id,
+					key: new Date(decoded.raw.receivedAt).getTime(),
+					tagUris,
+					attachments
+				};
+			});
+			const toItem = (email) => ({
+				foreignId: email.id,
+				key: new Date(email.receivedAt).getTime(),
+				process: toMapped(email).pipe(Effect.provide(context))
+			});
+			const captureFreshDelta = Effect.map(api.emailGet(target, []), (result) => ({
+				token: result.state,
+				createdIds: void 0,
+				updatedIds: [],
+				hasMoreDelta: false
+			}));
+			const { token: capturedToken, createdIds, updatedIds, hasMoreDelta } = yield* token === void 0 ? captureFreshDelta : api.emailChanges(target, token, maxMessages).pipe(Effect.map((result) => {
+				const created = new Set(result.created);
+				const updatedIds = result.updated.filter((id) => !created.has(id));
+				log("jmap sync: incremental delta", {
+					created: result.created.length,
+					updated: result.updated.length,
+					destroyed: result.destroyed.length,
+					hasMoreDelta: result.hasMoreChanges
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 180,
+					S: this
+				});
+				return {
+					token: result.newState,
+					createdIds: result.created,
+					updatedIds,
+					hasMoreDelta: result.hasMoreChanges
+				};
+			}), Effect.catchIf((error) => error.type === "cannotCalculateChanges", () => {
+				log("jmap sync: state token stale, falling back to window scan", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 196,
+					S: this
+				});
+				Cursor.clearToken(binding);
+				return captureFreshDelta;
+			}));
+			return {
+				buildSource: ({ windows, filter, tagIndex, onEnumerated, onRetrieved }) => {
+					const forwardIds = filter ? void 0 : createdIds;
+					if (forwardIds) onEnumerated(forwardIds.length);
+					return {
+						additions: jmapEmails(target, folders, {
+							windows,
+							filter,
+							now,
+							onEnumerated,
+							onRetrieved,
+							forwardIds
+						}).pipe(Stream.map(toItem), Stream.provideService(JmapMailApi, providerApi), Stream.mapError(MailSyncError.wrap())),
+						reconciles: jmapReconcile(updatedIds, target, folderTagMap, keywordTagMap, tagIndex).pipe(Stream.provideService(JmapMailApi, providerApi), Stream.mapError(MailSyncError.wrap()))
+					};
+				},
+				nextToken: () => capturedToken,
+				reconcileForeignIds: updatedIds,
+				hasMoreDelta: () => hasMoreDelta
+			};
+		}).pipe(Effect.provide(context), Effect.mapError(MailSyncError.wrap()))
+	};
+}));
+/**
+* Reconcile branch for JMAP: for each `updated` email id, re-fetch its current `mailboxIds` + `keywords`,
+* map them to Tags, and diff against the message's current *local* tags — a remote-wins, snapshot-free
+* reconciliation that is idempotent (a crash re-run produces an empty diff). Emits a retag
+* {@link EmailStage.Change} keyed by the resolved EntityId; ids not in the feed or with no net change are
+* dropped.
+*
+* The two axes differ: **folder** tags are fully remote-wins (added *and* removed, since folder
+* membership is server-authoritative), while **keyword** tags (starred) are **add-only** — the remote can
+* add a star but we never auto-remove one, which would clobber a locally-toggled star until we write
+* local flags back to the provider.
+*/
+var jmapReconcile = (updatedIds, target, folderTagMap, keywordTagMap, tagIndex) => {
+	const folderProviderUris = new Set(folderTagMap.values());
+	return Stream.fromIterable(updatedIds).pipe(Stage.map("jmap-reconcile", (id) => Effect.gen(function* () {
+		const { foreignIndex } = yield* Cursor.Service;
+		const entityId = foreignIndex?.get(id);
+		if (!entityId) return;
+		const { list } = yield* (yield* JmapMailApi).emailGet(target, [id]);
+		const email = list[0];
+		if (!email) return;
+		const remoteFolderUris = (email.mailboxIds ? Object.keys(email.mailboxIds) : []).flatMap((folderId) => {
+			const uri = folderTagMap.get(folderId);
+			return uri ? [uri] : [];
+		});
+		const remoteKeywordUris = (email.keywords ? Object.entries(email.keywords).filter(([, set]) => set).map(([keyword]) => keyword) : []).flatMap((keyword) => {
+			const uri = keywordTagMap.get(keyword);
+			return uri ? [uri] : [];
+		});
+		const localTags = TagIndex.bind(tagIndex).tags(entityId);
+		const remoteFolders = new Set(remoteFolderUris);
+		const addTagIds = [...remoteFolderUris, ...remoteKeywordUris].filter((tagUri) => !localTags.includes(tagUri));
+		const removeTagIds = localTags.filter((tagUri) => folderProviderUris.has(tagUri) && !remoteFolders.has(tagUri));
+		if (addTagIds.length === 0 && removeTagIds.length === 0) return;
+		return {
+			_tag: "retag",
+			foreignId: id,
+			entityId,
+			addTagIds,
+			removeTagIds
+		};
+	})));
+};
+/**
+* Downloads each attachment's bytes via `JmapMailApi.downloadBlob`. One failed download (including a
+* session with no `downloadUrl`) is logged and dropped rather than failing the whole message.
+*/
+var fetchAttachments = (target, attachments) => Effect.gen(function* () {
+	const api = yield* JmapMailApi;
+	return (yield* Effect.forEach(attachments, (attachment) => api.downloadBlob(target, attachment.blobId, {
+		name: attachment.name,
+		type: attachment.mimeType
+	}).pipe(Effect.map((bytes) => ({
+		name: attachment.name,
+		mimeType: attachment.mimeType,
+		size: attachment.size ?? bytes.byteLength,
+		bytes,
+		contentId: attachment.contentId
+	})), Effect.catchAll((error) => {
+		log.catch(error, {
+			blobId: attachment.blobId,
+			name: attachment.name
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 332,
+			S: this
+		});
+		return Effect.succeed(void 0);
+	})), { concurrency: JMAP_SYNC_CONFIG.fetchConcurrency })).filter((attachment) => attachment !== void 0);
+});
+/**
+* Streams JMAP email ids over a {@link Cursor.Window}: build the query filter (folder scope + date
+* bounds + optional user DSL), then paginate. Forward pages oldest-first from `max` so a capped run
+* advances `max` gap-free instead of jumping to the newest key and stranding the middle; backward pages
+* newest-first from `min` to the horizon. Backward's upper bound is queried 1ms past `min` so a message
+* sharing that exact millisecond is re-queried (and deduped) rather than skipped once `min` passes it.
+* Split from the full-email fetch so a bidirectional run can cap the combined id stream before fetching.
+*/
+var jmapIds = (target, folders, window, options) => Stream.unwrap(Effect.gen(function* () {
+	const api = yield* JmapMailApi;
+	const userFilter = options.filter ? parseMailQuery(options.filter, {
+		now: options.now,
+		resolveMailbox: (nameOrRole) => resolveMailboxByNameOrRole(folders, nameOrRole)
+	}) : Option.none();
+	const scopesMailbox = Option.match(userFilter, {
+		onNone: () => false,
+		onSome: filterScopesMailbox
+	});
+	const excludedFolderIds = folders.filter((folder) => folder.role === "trash" || folder.role === "junk" || folder.role === "drafts").map((folder) => folder.id);
+	const conditions = [];
+	if (!scopesMailbox && excludedFolderIds.length > 0) conditions.push({ inMailboxOtherThan: excludedFolderIds });
+	const upperBound = window.direction === "backward" ? new Date(window.end.getTime() + 1) : window.end;
+	conditions.push({ after: window.start.toISOString() });
+	conditions.push({ before: upperBound.toISOString() });
+	if (Option.isSome(userFilter)) conditions.push(userFilter.value);
+	const filter = conditions.length === 1 ? conditions[0] : {
+		operator: "AND",
+		conditions
+	};
+	log("starting jmap sync", {
+		direction: window.direction,
+		start: window.start.toISOString(),
+		end: window.end.toISOString(),
+		conditions: conditions.length
+	}, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 391,
+		S: this
+	});
+	return Stream.paginateChunkEffect(0, (position) => Effect.gen(function* () {
+		const { ids } = yield* api.emailQuery(target, {
+			filter,
+			sort: [{
+				property: "receivedAt",
+				isAscending: window.direction === "forward"
+			}],
+			position,
+			limit: JMAP_SYNC_CONFIG.listPageSize
+		});
+		log("jmap sync: queried page", {
+			position,
+			total: ids.length
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 406,
+			S: this
+		});
+		options.onEnumerated?.(ids.length);
+		const next = ids.length < JMAP_SYNC_CONFIG.listPageSize ? Option.none() : Option.some(position + ids.length);
+		return [Chunk.fromIterable(ids), next];
+	}));
+}));
+/**
+* Fetches the full JMAP email for each id. Takes a plain id stream (not a window) so a bidirectional
+* run can cap the combined stream once, then fetch full emails for exactly the capped set.
+*/
+var jmapEmailsForIds = (target, ids, options = {}) => ids.pipe(Stream.flatMap((id) => Stream.fromEffect(Effect.gen(function* () {
+	const { list } = yield* (yield* JmapMailApi).emailGet(target, [id]);
+	options.onRetrieved?.();
+	return list[0];
+})).pipe(Stream.filter(Predicate.isNotNullable)), {
+	concurrency: JMAP_SYNC_CONFIG.fetchConcurrency,
+	bufferSize: 10
+}));
+/**
+* Streams full JMAP emails for one run: the forward source's ids then the backward window's,
+* concatenated and fetched in full. Intentionally UNBOUNDED — the harness caps after dedup (see
+* `runMailSync`). The forward source is either the `max`-anchored forward window (first tick / stale
+* fallback) or, when `forwardIds` is set, the incremental delta's created ids — in which case the
+* backward window still runs, so an incremental tick keeps making backfill progress.
+*
+* `Cursor.skipCommitted` drops ids already in the dedup set before `emailGet`, so re-queried boundary
+* ids aren't downloaded; the harness's post-fetch `Cursor.dedupStage` stays the authority.
+*/
+var jmapEmails = (target, folders, config) => {
+	const idsFor = (window) => window ? jmapIds(target, folders, window, {
+		filter: config.filter,
+		now: config.now,
+		onEnumerated: config.onEnumerated
+	}) : Stream.empty;
+	const forward = config.forwardIds ? Stream.fromIterable(config.forwardIds) : idsFor(config.windows.forward);
+	return jmapEmailsForIds(target, Stream.concat(forward, idsFor(config.windows.backward)).pipe(Cursor.skipCommitted("skip-committed", (id) => id)), { onRetrieved: config.onRetrieved });
+};
+//#endregion
+export { jmapMailSyncProvider as t };
+
+//# sourceMappingURL=chunk-sync-provider.mjs.map