@dxos/plugin-jmap 0.10.0

package/dist/lib/chunk-apis.mjs

@@ -0,0 +1,756 @@
+import { t as JmapApiError } from "./chunk-errors.mjs";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import * as Schema from "effect/Schema";
+import { withAuthorization } from "@dxos/compute-runtime";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import { Database } from "@dxos/echo";
+import { log } from "@dxos/log";
+import { subDays, subMonths, subWeeks, subYears } from "date-fns";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/services/jmap-credentials.ts
+var __dxlog_file = "/Users/burdon/Code/dxos/dxos/.claude/worktrees/confident-jones-b0b4bf/packages/plugins/plugin-jmap/src/services/jmap-credentials.ts";
+/**
+* Service for accessing JMAP credentials.
+*
+* Mirrors `GoogleCredentials`: an operation invoked with a `Connection` composes
+* `fromConnection(ref)`; one invoked with an external-sync cursor composes
+* `fromAccessToken(cursor.spec.source)` directly (the cursor no longer relates to `Connection`).
+* Unlike Google, there is no database-credential fallback — a JMAP connection always carries host +
+* token in its token record.
+*/
+var JmapCredentials = class JmapCredentials extends Context.Tag("JmapCredentials")() {
+	/** Creates a credentials layer from an AccessToken ref. Loads its `source` (host), `account`, `token`. */
+	static fromAccessToken = (accessTokenRef) => Layer.effect(JmapCredentials, Effect.gen(function* () {
+		const accessToken = yield* Database.load(accessTokenRef);
+		log("using access token", { source: accessToken.source }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 41,
+			S: this
+		});
+		return {
+			host: accessToken.source,
+			account: accessToken.account,
+			token: accessToken.token
+		};
+	}));
+	/** Creates a credentials layer from a Connection ref. Loads its `accessToken`'s host/account/token. */
+	static fromConnection = (connectionRef) => Layer.effect(JmapCredentials, Effect.gen(function* () {
+		const connection = yield* Database.load(connectionRef);
+		const accessToken = yield* Database.load(connection.accessToken);
+		log("using connection access token", { source: accessToken.source }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 53,
+			S: this
+		});
+		return {
+			host: accessToken.source,
+			account: accessToken.account,
+			token: accessToken.token
+		};
+	}));
+	/** Creates a credentials layer from explicit values (credential-form validation and tests). */
+	static fromValues = (values) => Layer.succeed(JmapCredentials, {
+		host: values.host,
+		account: values.account,
+		token: values.token
+	});
+};
+//#endregion
+//#region src/apis/Jmap/types.ts
+/** Session object returned from `https://${host}/.well-known/jmap` (RFC 8620 §2). */
+var Session = Schema.Struct({
+	/** Endpoint for all subsequent API requests. */
+	apiUrl: Schema.String,
+	/**
+	* URI Template (RFC 6570) for blob downloads, with `accountId`/`blobId`/`type`/`name` variables
+	* (RFC 8620 §6.2). Required, matching the spec — every real JMAP session advertises one.
+	*/
+	downloadUrl: Schema.String,
+	/** Authenticated username (used to seed the connection account when the form leaves it blank). */
+	username: Schema.optional(Schema.String),
+	/** Capability urn → primary account id (e.g. `urn:ietf:params:jmap:mail`). */
+	primaryAccounts: Schema.Record({
+		key: Schema.String,
+		value: Schema.String
+	}),
+	accounts: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	})),
+	capabilities: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	})),
+	state: Schema.optional(Schema.String)
+});
+/** A method-level error response: `["error", { type, description }, callId]` (RFC 8620 §3.6.1). */
+var MethodError = Schema.Struct({
+	type: Schema.String,
+	description: Schema.optional(Schema.NullOr(Schema.String))
+});
+/** A single `[name, args, callId]` invocation result; `args` is decoded per-method by the caller. */
+var MethodResponse = Schema.Tuple(Schema.String, Schema.Unknown, Schema.String);
+/** The top-level response envelope of a batched API request (RFC 8620 §3.3). */
+var Response = Schema.Struct({
+	methodResponses: Schema.Array(MethodResponse),
+	sessionState: Schema.optional(Schema.String)
+});
+//#endregion
+//#region src/apis/Jmap/api.ts
+/** Shared per-attempt timeout/retry policy for JMAP HTTP requests (session, batched API, blob download). */
+var REQUEST_TIMEOUT = "10 seconds";
+var REQUEST_RETRY = Schedule.exponential(1e3).pipe(Schedule.compose(Schedule.recurs(3)));
+var shouldRetry = (error) => !(error instanceof JmapApiError && error.status !== void 0 && error.status >= 400 && error.status < 500);
+/** Capability set for read/write mail requests. */
+var MAIL_CAPABILITIES = ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:mail"];
+/** Capability set including submission, required to send mail. */
+var SUBMISSION_CAPABILITIES = [...MAIL_CAPABILITIES, "urn:ietf:params:jmap:submission"];
+/**
+* Discovers the JMAP session: `GET https://${host}/.well-known/jmap` (the well-known URL
+* 302-redirects to the session resource, which `fetch` follows). Yields `apiUrl` +
+* `primaryAccounts`. Tracer disabled (Effect + CORS: https://github.com/Effect-TS/effect/issues/4568).
+*/
+var getSession = Effect.gen(function* () {
+	const { host, token } = yield* JmapCredentials;
+	const httpClientWithTracerDisabled = (yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(token, "Bearer")))).pipe(HttpClient.withTracerDisabledWhen(() => true));
+	return yield* HttpClientRequest.get(`https://${host}/.well-known/jmap`).pipe(HttpClientRequest.setHeader("accept", "application/json"), httpClientWithTracerDisabled.execute, Effect.flatMap(decodeJsonOrFail(Session)), Effect.timeout(REQUEST_TIMEOUT), Effect.retry({
+		schedule: REQUEST_RETRY,
+		while: shouldRetry
+	}), Effect.scoped, Effect.withSpan("JmapGetSession"), Effect.mapError(asJmapApiError));
+});
+/**
+* Issues a batched JMAP API request (single POST to the session `apiUrl`) and decodes the response
+* envelope. Read requests retry on transient failure; pass `{ retry: false }` for non-idempotent
+* writes (draft create + submission) so a retry can't double-send.
+*/
+var jmapRequest = (apiUrl, body, options = {}) => Effect.gen(function* () {
+	const { token } = yield* JmapCredentials;
+	const httpClientWithTracerDisabled = (yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(token, "Bearer")))).pipe(HttpClient.withTracerDisabledWhen(() => true));
+	const executed = HttpClientRequest.post(apiUrl).pipe(HttpClientRequest.setHeader("accept", "application/json"), HttpClientRequest.bodyUnsafeJson(body), httpClientWithTracerDisabled.execute, Effect.flatMap(decodeJsonOrFail(Response)), Effect.timeout(REQUEST_TIMEOUT));
+	return yield* (options.retry === false ? executed : executed.pipe(Effect.retry({
+		schedule: REQUEST_RETRY,
+		while: shouldRetry
+	}))).pipe(Effect.scoped, Effect.withSpan("JmapApiRequest"), Effect.mapError(asJmapApiError));
+});
+/**
+* Extracts and decodes the result for a given `callId` from a response envelope. A method-level
+* `["error", …]` response (or a decode failure) becomes a typed {@link JmapApiError}.
+*/
+var getMethodResponse = (response, callId, schema) => {
+	const entry = response.methodResponses.find((methodResponse) => methodResponse[2] === callId);
+	if (!entry) return Effect.fail(new JmapApiError(void 0, `No method response for call ${callId}.`));
+	const [name, args] = entry;
+	if (name === "error") return Schema.decodeUnknown(MethodError)(args).pipe(Effect.matchEffect({
+		onFailure: () => Effect.fail(new JmapApiError(void 0, `JMAP method error (${callId}).`)),
+		onSuccess: (error) => Effect.fail(new JmapApiError(void 0, error.description ?? error.type, error.type))
+	}));
+	return Schema.decodeUnknown(schema)(args).pipe(Effect.mapError(asJmapApiError));
+};
+/** Decodes a 2xx JSON body against `schema`; a >=400 status fails with the (truncated) body text. */
+var decodeJsonOrFail = (schema) => (response) => Effect.gen(function* () {
+	if (response.status >= 400) {
+		const body = yield* response.text;
+		return yield* Effect.fail(new JmapApiError(response.status, truncate(body)));
+	}
+	return yield* HttpClientResponse.schemaBodyJson(schema)(response);
+}).pipe(Effect.mapError(asJmapApiError));
+/** Collapses transport/decode failures (HttpClientError, ParseError, timeout) into a typed JmapApiError. */
+var asJmapApiError = (error) => error instanceof JmapApiError ? error : new JmapApiError(void 0, error instanceof Error ? error.message : String(error));
+var truncate = (text, max = 500) => text.length > max ? `${text.slice(0, max)}…` : text;
+//#endregion
+//#region src/apis/Jmap/index.ts
+var Jmap_exports = /* @__PURE__ */ __exportAll({
+	MAIL_CAPABILITIES: () => MAIL_CAPABILITIES,
+	MethodError: () => MethodError,
+	MethodResponse: () => MethodResponse,
+	REQUEST_RETRY: () => REQUEST_RETRY,
+	REQUEST_TIMEOUT: () => REQUEST_TIMEOUT,
+	Response: () => Response,
+	SUBMISSION_CAPABILITIES: () => SUBMISSION_CAPABILITIES,
+	Session: () => Session,
+	getMethodResponse: () => getMethodResponse,
+	getSession: () => getSession,
+	jmapRequest: () => jmapRequest,
+	shouldRetry: () => shouldRetry
+});
+//#endregion
+//#region src/apis/JmapMail/types.ts
+/** Structured email address — JMAP gives `{ name, email }` directly (no header parsing). */
+var EmailAddress = Schema.Struct({
+	name: Schema.optional(Schema.NullOr(Schema.String)),
+	email: Schema.String
+});
+/** A folder. `role` is a well-known role (`inbox`, `drafts`, `sent`, `trash`, …) or null for custom folders. */
+var Mailbox = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	role: Schema.optional(Schema.NullOr(Schema.String)),
+	parentId: Schema.optional(Schema.NullOr(Schema.String)),
+	sortOrder: Schema.optional(Schema.Number),
+	totalEmails: Schema.optional(Schema.Number),
+	unreadEmails: Schema.optional(Schema.Number)
+});
+/** A decoded body part value (when fetched with `fetchTextBodyValues`). */
+var BodyValue = Schema.Struct({
+	value: Schema.String,
+	isEncodingProblem: Schema.optional(Schema.Boolean),
+	isTruncated: Schema.optional(Schema.Boolean)
+});
+/** A body part reference (the `partId` keys into `Email.bodyValues`; `blobId` fetches raw bytes). */
+var EmailBodyPart = Schema.Struct({
+	partId: Schema.optional(Schema.NullOr(Schema.String)),
+	blobId: Schema.optional(Schema.NullOr(Schema.String)),
+	size: Schema.optional(Schema.Number),
+	type: Schema.optional(Schema.String),
+	charset: Schema.optional(Schema.NullOr(Schema.String)),
+	/** Attachment filename, present on parts listed in `Email.attachments`. */
+	name: Schema.optional(Schema.NullOr(Schema.String)),
+	/** MIME `Content-Disposition` (`attachment` or `inline`), present on parts listed in `Email.attachments`. */
+	disposition: Schema.optional(Schema.NullOr(Schema.String)),
+	/** The part's `Content-ID` header (RFC 8621 §4.1.4), if any — matches a `cid:` reference in an HTML body. */
+	cid: Schema.optional(Schema.NullOr(Schema.String))
+});
+/** An email (RFC 8621 §4). Only the properties requested in `Email/get` are present. */
+var Email = Schema.Struct({
+	id: Schema.String,
+	blobId: Schema.optional(Schema.String),
+	threadId: Schema.String,
+	mailboxIds: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: Schema.Boolean
+	})),
+	keywords: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: Schema.Boolean
+	})),
+	from: Schema.optional(Schema.NullOr(Schema.Array(EmailAddress))),
+	to: Schema.optional(Schema.NullOr(Schema.Array(EmailAddress))),
+	cc: Schema.optional(Schema.NullOr(Schema.Array(EmailAddress))),
+	bcc: Schema.optional(Schema.NullOr(Schema.Array(EmailAddress))),
+	subject: Schema.optional(Schema.NullOr(Schema.String)),
+	receivedAt: Schema.String,
+	sentAt: Schema.optional(Schema.NullOr(Schema.String)),
+	preview: Schema.optional(Schema.NullOr(Schema.String)),
+	messageId: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+	inReplyTo: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+	references: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+	bodyValues: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: BodyValue
+	})),
+	textBody: Schema.optional(Schema.Array(EmailBodyPart)),
+	htmlBody: Schema.optional(Schema.Array(EmailBodyPart)),
+	/** Non-body parts (RFC 8621 §4.1.4) — the attachments proper, distinct from `textBody`/`htmlBody`. */
+	attachments: Schema.optional(Schema.Array(EmailBodyPart))
+});
+/** A sending identity (RFC 8621 §6); `email` is an address the server permits as `from`. */
+var Identity = Schema.Struct({
+	id: Schema.String,
+	name: Schema.optional(Schema.NullOr(Schema.String)),
+	email: Schema.String
+});
+var MailboxGetResult = Schema.Struct({
+	accountId: Schema.optional(Schema.String),
+	state: Schema.optional(Schema.String),
+	list: Schema.Array(Mailbox),
+	notFound: Schema.optional(Schema.NullOr(Schema.Array(Schema.String)))
+});
+var EmailQueryResult = Schema.Struct({
+	accountId: Schema.optional(Schema.String),
+	queryState: Schema.optional(Schema.String),
+	position: Schema.optional(Schema.Number),
+	total: Schema.optional(Schema.Number),
+	limit: Schema.optional(Schema.Number),
+	ids: Schema.Array(Schema.String)
+});
+var EmailGetResult = Schema.Struct({
+	accountId: Schema.optional(Schema.String),
+	state: Schema.optional(Schema.String),
+	list: Schema.Array(Email),
+	notFound: Schema.optional(Schema.NullOr(Schema.Array(Schema.String)))
+});
+/** `Email/changes` delta since an opaque `sinceState` token (RFC 8621 §4.3 / RFC 8620 §5.2). */
+var EmailChangesResult = Schema.Struct({
+	accountId: Schema.optional(Schema.String),
+	oldState: Schema.String,
+	newState: Schema.String,
+	hasMoreChanges: Schema.Boolean,
+	created: Schema.Array(Schema.String),
+	updated: Schema.Array(Schema.String),
+	destroyed: Schema.Array(Schema.String)
+});
+var IdentityGetResult = Schema.Struct({
+	accountId: Schema.optional(Schema.String),
+	state: Schema.optional(Schema.String),
+	list: Schema.Array(Identity),
+	notFound: Schema.optional(Schema.NullOr(Schema.Array(Schema.String)))
+});
+var EmailSetResult = Schema.Struct({
+	accountId: Schema.optional(Schema.String),
+	oldState: Schema.optional(Schema.NullOr(Schema.String)),
+	newState: Schema.optional(Schema.String),
+	created: Schema.optional(Schema.NullOr(Schema.Record({
+		key: Schema.String,
+		value: Schema.Struct({
+			id: Schema.String,
+			blobId: Schema.optional(Schema.String),
+			threadId: Schema.optional(Schema.String),
+			size: Schema.optional(Schema.Number)
+		})
+	}))),
+	updated: Schema.optional(Schema.NullOr(Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	}))),
+	destroyed: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+	notCreated: Schema.optional(Schema.NullOr(Schema.Record({
+		key: Schema.String,
+		value: Schema.Struct({
+			type: Schema.String,
+			description: Schema.optional(Schema.NullOr(Schema.String))
+		})
+	}))),
+	notUpdated: Schema.optional(Schema.NullOr(Schema.Record({
+		key: Schema.String,
+		value: Schema.Struct({
+			type: Schema.String,
+			description: Schema.optional(Schema.NullOr(Schema.String))
+		})
+	}))),
+	notDestroyed: Schema.optional(Schema.NullOr(Schema.Record({
+		key: Schema.String,
+		value: Schema.Struct({
+			type: Schema.String,
+			description: Schema.optional(Schema.NullOr(Schema.String))
+		})
+	})))
+});
+var EmailSubmissionSetResult = Schema.Struct({
+	accountId: Schema.optional(Schema.String),
+	newState: Schema.optional(Schema.String),
+	created: Schema.optional(Schema.NullOr(Schema.Record({
+		key: Schema.String,
+		value: Schema.Struct({ id: Schema.String })
+	}))),
+	notCreated: Schema.optional(Schema.NullOr(Schema.Record({
+		key: Schema.String,
+		value: Schema.Struct({
+			type: Schema.String,
+			description: Schema.optional(Schema.NullOr(Schema.String))
+		})
+	})))
+});
+//#endregion
+//#region src/apis/JmapMail/api.ts
+/** Expands a JMAP `downloadUrl` URI Template (RFC 6570 level 1) with the given variables. */
+var expandDownloadUrl = (template, variables) => template.replace(/\{(\w+)\}/g, (_, key) => key in variables ? encodeURIComponent(variables[key]) : "");
+/**
+* Downloads a blob's raw bytes via the session's `downloadUrl` template. `name`/`type` are advisory
+* (they only affect the response's `Content-Disposition`/`Accept`), not required for correctness.
+*/
+var downloadBlob = Effect.fn("downloadBlob")(function* (target, blobId, options = {}) {
+	if (!target.downloadUrl) return yield* Effect.fail(new JmapApiError(void 0, "Session has no downloadUrl."));
+	const url = expandDownloadUrl(target.downloadUrl, {
+		accountId: target.accountId,
+		blobId,
+		name: options.name ?? blobId,
+		type: options.type ?? "application/octet-stream"
+	});
+	const { token } = yield* JmapCredentials;
+	const httpClient = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(token, "Bearer")));
+	const buffer = yield* HttpClientRequest.get(url).pipe(httpClient.execute, Effect.flatMap((response) => response.arrayBuffer), Effect.mapError(asJmapDownloadError), Effect.timeout(REQUEST_TIMEOUT), Effect.retry({
+		schedule: REQUEST_RETRY,
+		while: shouldRetry
+	}), Effect.scoped, Effect.mapError(asJmapDownloadError));
+	return new Uint8Array(buffer);
+});
+/** Collapses transport/decode failures into a typed {@link JmapApiError} (mirrors `Jmap/api.ts`). */
+var asJmapDownloadError = (error) => error instanceof JmapApiError ? error : new JmapApiError(void 0, error instanceof Error ? error.message : String(error));
+/** Email properties fetched by {@link emailGet} — enough for the mapper to build a Message. */
+var EMAIL_PROPERTIES = [
+	"id",
+	"blobId",
+	"threadId",
+	"mailboxIds",
+	"keywords",
+	"from",
+	"to",
+	"cc",
+	"subject",
+	"receivedAt",
+	"sentAt",
+	"preview",
+	"messageId",
+	"inReplyTo",
+	"references",
+	"bodyValues",
+	"textBody",
+	"htmlBody",
+	"attachments"
+];
+/** Lists all folders (mailboxes) in the account (RFC 8621 §2.3). */
+var mailboxGet = Effect.fn("mailboxGet")(function* (target) {
+	return yield* getMethodResponse(yield* jmapRequest(target.apiUrl, {
+		using: MAIL_CAPABILITIES,
+		methodCalls: [[
+			"Mailbox/get",
+			{
+				accountId: target.accountId,
+				ids: null
+			},
+			"0"
+		]]
+	}), "0", MailboxGetResult);
+});
+/** Queries email ids matching a filter (RFC 8621 §4.4). */
+var emailQuery = Effect.fn("emailQuery")(function* (target, options = {}) {
+	const args = { accountId: target.accountId };
+	if (options.filter !== void 0) args.filter = options.filter;
+	if (options.sort !== void 0) args.sort = options.sort;
+	if (options.position !== void 0) args.position = options.position;
+	if (options.limit !== void 0) args.limit = options.limit;
+	if (options.calculateTotal !== void 0) args.calculateTotal = options.calculateTotal;
+	return yield* getMethodResponse(yield* jmapRequest(target.apiUrl, {
+		using: MAIL_CAPABILITIES,
+		methodCalls: [[
+			"Email/query",
+			args,
+			"0"
+		]]
+	}), "0", EmailQueryResult);
+});
+/** Fetches emails by id with decoded HTML and text body values (RFC 8621 §4.2). */
+var emailGet = Effect.fn("emailGet")(function* (target, ids, properties = EMAIL_PROPERTIES) {
+	return yield* getMethodResponse(yield* jmapRequest(target.apiUrl, {
+		using: MAIL_CAPABILITIES,
+		methodCalls: [[
+			"Email/get",
+			{
+				accountId: target.accountId,
+				ids,
+				properties,
+				fetchTextBodyValues: true,
+				fetchHTMLBodyValues: true
+			},
+			"0"
+		]]
+	}), "0", EmailGetResult);
+});
+/**
+* Fetches the delta of email changes since an opaque `sinceState` token (RFC 8621 §4.3). A server that
+* can't compute the delta (state too old / evicted) returns a `cannotCalculateChanges` method error,
+* surfaced as a {@link JmapApiError} with that `type` — the caller's cue to fall back to a full scan.
+* The token to pass comes from a prior `Email/get` `state` (NOT `Email/query` `queryState`).
+*/
+var emailChanges = Effect.fn("emailChanges")(function* (target, sinceState, maxChanges) {
+	const args = {
+		accountId: target.accountId,
+		sinceState
+	};
+	if (maxChanges !== void 0) args.maxChanges = maxChanges;
+	return yield* getMethodResponse(yield* jmapRequest(target.apiUrl, {
+		using: MAIL_CAPABILITIES,
+		methodCalls: [[
+			"Email/changes",
+			args,
+			"0"
+		]]
+	}), "0", EmailChangesResult);
+});
+/** Lists the account's sending identities (RFC 8621 §6.2). */
+var identityGet = Effect.fn("identityGet")(function* (target) {
+	return yield* getMethodResponse(yield* jmapRequest(target.apiUrl, {
+		using: SUBMISSION_CAPABILITIES,
+		methodCalls: [[
+			"Identity/get",
+			{
+				accountId: target.accountId,
+				ids: null
+			},
+			"0"
+		]]
+	}), "0", IdentityGetResult);
+});
+/** Patches a single email (e.g. replace `mailboxIds` to move to Trash). Idempotent, so retryable. */
+var emailSetUpdate = Effect.fn("emailSetUpdate")(function* (target, emailId, patch) {
+	const result = yield* getMethodResponse(yield* jmapRequest(target.apiUrl, {
+		using: MAIL_CAPABILITIES,
+		methodCalls: [[
+			"Email/set",
+			{
+				accountId: target.accountId,
+				update: { [emailId]: patch }
+			},
+			"0"
+		]]
+	}), "0", EmailSetResult);
+	const error = result.notUpdated?.[emailId];
+	if (error) return yield* Effect.fail(new JmapApiError(void 0, error.description ?? error.type, error.type));
+	return result;
+});
+/**
+* Creates a draft and submits it for delivery in a single batched request. Not retried (a retry
+* could double-send). Returns the created email's id and thread id.
+*/
+var submitEmail = Effect.fn("submitEmail")(function* (target, args) {
+	const { identityId, draftsMailboxId, sentMailboxId, draft } = args;
+	const draftCreate = {
+		mailboxIds: { [draftsMailboxId]: true },
+		keywords: {
+			$draft: true,
+			$seen: true
+		},
+		from: draft.from,
+		to: draft.to,
+		bodyValues: { body: { value: draft.text } },
+		textBody: [{
+			partId: "body",
+			type: "text/plain"
+		}]
+	};
+	if (draft.cc && draft.cc.length > 0) draftCreate.cc = draft.cc;
+	if (draft.bcc && draft.bcc.length > 0) draftCreate.bcc = draft.bcc;
+	if (draft.subject !== void 0) draftCreate.subject = draft.subject;
+	if (draft.inReplyTo && draft.inReplyTo.length > 0) draftCreate.inReplyTo = draft.inReplyTo;
+	if (draft.references && draft.references.length > 0) draftCreate.references = draft.references;
+	const response = yield* jmapRequest(target.apiUrl, {
+		using: SUBMISSION_CAPABILITIES,
+		methodCalls: [[
+			"Email/set",
+			{
+				accountId: target.accountId,
+				create: { draft: draftCreate }
+			},
+			"0"
+		], [
+			"EmailSubmission/set",
+			{
+				accountId: target.accountId,
+				create: { sub: {
+					emailId: "#draft",
+					identityId
+				} },
+				onSuccessUpdateEmail: { "#sub": {
+					[`mailboxIds/${draftsMailboxId}`]: null,
+					[`mailboxIds/${sentMailboxId}`]: true,
+					"keywords/$draft": null
+				} }
+			},
+			"1"
+		]]
+	}, { retry: false });
+	const setResult = yield* getMethodResponse(response, "0", EmailSetResult);
+	const created = setResult.created?.draft;
+	if (!created) {
+		const error = setResult.notCreated?.draft;
+		return yield* Effect.fail(new JmapApiError(void 0, error?.description ?? error?.type ?? "Draft was not created.", error?.type));
+	}
+	const submissionResult = yield* getMethodResponse(response, "1", EmailSubmissionSetResult);
+	if (!submissionResult.created?.sub) {
+		const error = submissionResult.notCreated?.sub;
+		return yield* Effect.fail(new JmapApiError(void 0, error?.description ?? error?.type ?? "Email submission failed.", error?.type));
+	}
+	return {
+		id: created.id,
+		threadId: created.threadId
+	};
+});
+//#endregion
+//#region src/apis/JmapMail/query.ts
+/**
+* Translates a Gmail-like query string into a JMAP `Email/query` filter (RFC 8621 §4.4.1).
+*
+* Supported operators: `from:`/`to:`/`cc:`/`bcc:`/`subject:`/`body:`, `label:`/`in:` (resolved to a
+* mailbox id), `is:unread|read|starred|flagged|unstarred|draft|answered`, `has:attachment`,
+* `after:`/`before:` (`YYYY/MM/DD` or `YYYY-MM-DD`), `newer_than:`/`older_than:` (e.g. `7d`, `2w`,
+* `3m`, `1y`), `larger:`/`smaller:` (e.g. `10M`, `500k`), `list:`/`deliveredto:` (header match),
+* quoted phrases, `-` negation, `OR` groups, and bare words (full-text). Space-separated terms are
+* AND-ed. Returns `None` for an empty query, or one whose terms all fail to resolve (e.g. an unknown
+* label).
+*/
+var parseMailQuery = (query, ctx) => buildFilter(tokenize(query), ctx);
+/** Resolves a label/folder name (case-insensitive) or a system role/alias to a mailbox id. */
+var resolveMailboxByNameOrRole = (folders, nameOrRole) => {
+	const lowered = nameOrRole.toLowerCase();
+	const role = ROLE_ALIASES[lowered] ?? lowered;
+	const match = folders.find((folder) => folder.role === role) ?? folders.find((folder) => folder.name.toLowerCase() === lowered);
+	return Option.fromNullable(match?.id);
+};
+var TOKEN_RE = /-?(?:[A-Za-z_]+:)?"[^"]*"|\S+/g;
+var tokenize = (query) => (query.match(TOKEN_RE) ?? []).map(parseToken);
+var parseToken = (raw) => {
+	if (raw === "OR") return { _tag: "or" };
+	const negate = raw.startsWith("-");
+	const rest = negate ? raw.slice(1) : raw;
+	const colon = rest.indexOf(":");
+	if (colon > 0 && /^[A-Za-z_]+$/.test(rest.slice(0, colon))) return {
+		_tag: "term",
+		negate,
+		op: Option.some(rest.slice(0, colon).toLowerCase()),
+		value: stripQuotes(rest.slice(colon + 1))
+	};
+	return {
+		_tag: "term",
+		negate,
+		op: Option.none(),
+		value: stripQuotes(rest)
+	};
+};
+var stripQuotes = (value) => value.length >= 2 && value.startsWith("\"") && value.endsWith("\"") ? value.slice(1, -1) : value;
+var buildFilter = (tokens, ctx) => {
+	const { operands } = tokens.reduce((state, token) => {
+		if (token._tag === "or") return {
+			...state,
+			pendingOr: state.operands.length > 0
+		};
+		const leaf = buildTerm(token, ctx);
+		if (Option.isNone(leaf)) return {
+			...state,
+			pendingOr: false
+		};
+		const previous = state.pendingOr ? state.operands[state.operands.length - 1] : void 0;
+		return previous !== void 0 ? {
+			operands: [...state.operands.slice(0, -1), mergeOr(previous, leaf.value)],
+			pendingOr: false
+		} : {
+			operands: [...state.operands, leaf.value],
+			pendingOr: false
+		};
+	}, {
+		operands: [],
+		pendingOr: false
+	});
+	return Match.value(operands.length).pipe(Match.when(0, () => Option.none()), Match.when(1, () => Option.fromNullable(operands[0])), Match.orElse(() => Option.some({
+		operator: "AND",
+		conditions: operands
+	})));
+};
+var mergeOr = (previous, next) => isOperator(previous) && previous.operator === "OR" ? {
+	operator: "OR",
+	conditions: [...previous.conditions, next]
+} : {
+	operator: "OR",
+	conditions: [previous, next]
+};
+var isOperator = (filter) => "operator" in filter;
+/** Whether a filter restricts the mailbox scope (`inMailbox`/`inMailboxOtherThan`), recursively. */
+var filterScopesMailbox = (filter) => isOperator(filter) ? filter.conditions.some(filterScopesMailbox) : filter.inMailbox !== void 0 || filter.inMailboxOtherThan !== void 0;
+var buildTerm = (token, ctx) => buildLeaf(token.op, token.value, ctx).pipe(Option.map((leaf) => token.negate ? negate(leaf) : leaf));
+var negate = (filter) => ({
+	operator: "NOT",
+	conditions: [filter]
+});
+var buildLeaf = (op, value, ctx) => op.pipe(Option.match({
+	onNone: () => textLeaf(value),
+	onSome: (operator) => buildOperatorLeaf(operator, value, ctx)
+}));
+var buildOperatorLeaf = (operator, value, ctx) => Match.value(operator).pipe(Match.whenOr("from", "to", "cc", "bcc", "subject", "body", (field) => condLeaf(value, STRING_FIELD_LEAVES[field](value))), Match.whenOr("label", "in", () => ctx.resolveMailbox(value).pipe(Option.map((id) => ({ inMailbox: id })))), Match.when("is", () => Option.fromNullable(IS_LEAVES[value.toLowerCase()])), Match.when("has", () => value.toLowerCase() === "attachment" ? Option.some({ hasAttachment: true }) : Option.none()), Match.whenOr("after", "newer", () => dateLeaf(value, "after")), Match.whenOr("before", "older", () => dateLeaf(value, "before")), Match.when("newer_than", () => relativeDateLeaf(value, ctx.now, "after")), Match.when("older_than", () => relativeDateLeaf(value, ctx.now, "before")), Match.when("larger", () => sizeLeaf(value, "minSize")), Match.when("smaller", () => sizeLeaf(value, "maxSize")), Match.when("list", () => headerLeaf("List-Id", value)), Match.when("deliveredto", () => headerLeaf("Delivered-To", value)), Match.orElse(() => textLeaf(`${operator}:${value}`)));
+var STRING_FIELD_LEAVES = {
+	from: (value) => ({ from: value }),
+	to: (value) => ({ to: value }),
+	cc: (value) => ({ cc: value }),
+	bcc: (value) => ({ bcc: value }),
+	subject: (value) => ({ subject: value }),
+	body: (value) => ({ body: value })
+};
+var IS_LEAVES = {
+	unread: { notKeyword: "$seen" },
+	read: { hasKeyword: "$seen" },
+	starred: { hasKeyword: "$flagged" },
+	flagged: { hasKeyword: "$flagged" },
+	unstarred: { notKeyword: "$flagged" },
+	unflagged: { notKeyword: "$flagged" },
+	draft: { hasKeyword: "$draft" },
+	answered: { hasKeyword: "$answered" },
+	replied: { hasKeyword: "$answered" }
+};
+var ROLE_ALIASES = {
+	spam: "junk",
+	bin: "trash",
+	deleted: "trash"
+};
+var SIZE_UNITS = {
+	"": 1,
+	"k": 1024,
+	"m": 1024 * 1024,
+	"g": 1024 * 1024 * 1024
+};
+var DATE_RE = /^(\d{4})[/-](\d{1,2})[/-](\d{1,2})$/;
+var RELATIVE_RE = /^(\d+)([dwmy])$/;
+var SIZE_RE = /^(\d+)([kmg]?)b?$/i;
+/** Wraps a built condition in `Some`, or `None` when the value is blank. */
+var condLeaf = (value, condition) => value.trim().length === 0 ? Option.none() : Option.some(condition);
+var textLeaf = (value) => condLeaf(value, { text: value });
+var headerLeaf = (name, value) => condLeaf(value, { header: [name, value] });
+var dateLeaf = (value, bound) => {
+	const match = DATE_RE.exec(value);
+	if (!match) return Option.none();
+	const iso = new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]))).toISOString();
+	return Option.some(bound === "after" ? { after: iso } : { before: iso });
+};
+var relativeDateLeaf = (value, now, bound) => {
+	const match = RELATIVE_RE.exec(value.toLowerCase());
+	if (!match) return Option.none();
+	const amount = Number(match[1]);
+	const iso = Match.value(match[2]).pipe(Match.when("w", () => subWeeks(now, amount)), Match.when("m", () => subMonths(now, amount)), Match.when("y", () => subYears(now, amount)), Match.orElse(() => subDays(now, amount))).toISOString();
+	return Option.some(bound === "after" ? { after: iso } : { before: iso });
+};
+var sizeLeaf = (value, bound) => {
+	const match = SIZE_RE.exec(value.toLowerCase());
+	if (!match) return Option.none();
+	const bytes = Number(match[1]) * (SIZE_UNITS[match[2] ?? ""] ?? 1);
+	return Option.some(bound === "minSize" ? { minSize: bytes } : { maxSize: bytes });
+};
+//#endregion
+//#region src/apis/JmapMail/index.ts
+var JmapMail_exports = /* @__PURE__ */ __exportAll({
+	BodyValue: () => BodyValue,
+	EMAIL_PROPERTIES: () => EMAIL_PROPERTIES,
+	Email: () => Email,
+	EmailAddress: () => EmailAddress,
+	EmailBodyPart: () => EmailBodyPart,
+	EmailChangesResult: () => EmailChangesResult,
+	EmailGetResult: () => EmailGetResult,
+	EmailQueryResult: () => EmailQueryResult,
+	EmailSetResult: () => EmailSetResult,
+	EmailSubmissionSetResult: () => EmailSubmissionSetResult,
+	Identity: () => Identity,
+	IdentityGetResult: () => IdentityGetResult,
+	Mailbox: () => Mailbox,
+	MailboxGetResult: () => MailboxGetResult,
+	downloadBlob: () => downloadBlob,
+	emailChanges: () => emailChanges,
+	emailGet: () => emailGet,
+	emailQuery: () => emailQuery,
+	emailSetUpdate: () => emailSetUpdate,
+	filterScopesMailbox: () => filterScopesMailbox,
+	identityGet: () => identityGet,
+	mailboxGet: () => mailboxGet,
+	parseMailQuery: () => parseMailQuery,
+	resolveMailboxByNameOrRole: () => resolveMailboxByNameOrRole,
+	submitEmail: () => submitEmail
+});
+//#endregion
+export { downloadBlob as a, emailQuery as c, mailboxGet as d, submitEmail as f, JmapCredentials as h, resolveMailboxByNameOrRole as i, emailSetUpdate as l, getSession as m, filterScopesMailbox as n, emailChanges as o, Jmap_exports as p, parseMailQuery as r, emailGet as s, JmapMail_exports as t, identityGet as u };
+
+//# sourceMappingURL=chunk-apis.mjs.map