@remit/web-client 0.0.75 → 0.0.77

package/src/lib/mailbox-sync-wait.test.ts

@@ -0,0 +1,186 @@
+/**
+ * waitForMailboxSynced — the gate a dependent write (a filter, a move) holds
+ * behind while a freshly-created folder is confirmed on the mail server. It
+ * resolves only on `synced`, rejects distinctly on `failed` and on timeout, and
+ * keeps polling while the row is still `pending` or not yet listed.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { MailboxSyncStatus } from "@remit/domain-enums";
+import {
+	MAILBOX_SYNC_FAILED_MESSAGE,
+	MAILBOX_SYNC_TIMEOUT_MESSAGE,
+	type MailboxSyncSignal,
+	waitForMailboxSynced,
+} from "./mailbox-sync-wait.js";
+
+const row = (
+	mailboxId: string,
+	syncStatus?: MailboxSyncSignal["syncStatus"],
+	extra: Record<string, unknown> = {},
+): MailboxSyncSignal & Record<string, unknown> => ({
+	mailboxId,
+	syncStatus,
+	...extra,
+});
+
+const noDelay = () => Promise.resolve();
+
+describe("waitForMailboxSynced", () => {
+	it("resolves with the confirmed row once it reaches synced", async () => {
+		const responses = [
+			[row("mbx-1", MailboxSyncStatus.pending)],
+			[row("mbx-1", MailboxSyncStatus.pending)],
+			[row("mbx-1", MailboxSyncStatus.synced, { fullPath: "Server/Receipts" })],
+		];
+		let call = 0;
+		const result = await waitForMailboxSynced({
+			mailboxId: "mbx-1",
+			fetchMailboxes: async () => responses[call++],
+			delay: noDelay,
+		});
+		assert.equal(result.syncStatus, MailboxSyncStatus.synced);
+		assert.equal(
+			(result as Record<string, unknown>).fullPath,
+			"Server/Receipts",
+		);
+		assert.equal(call, 3);
+	});
+
+	it("keeps polling while the row is not yet listed", async () => {
+		const responses = [
+			[] as MailboxSyncSignal[],
+			[row("other", MailboxSyncStatus.synced)],
+			[row("mbx-1", MailboxSyncStatus.synced)],
+		];
+		let call = 0;
+		const result = await waitForMailboxSynced({
+			mailboxId: "mbx-1",
+			fetchMailboxes: async () => responses[call++],
+			delay: noDelay,
+		});
+		assert.equal(result.mailboxId, "mbx-1");
+		assert.equal(call, 3);
+	});
+
+	it("rejects with the failure message when the create is reported failed", async () => {
+		await assert.rejects(
+			waitForMailboxSynced({
+				mailboxId: "mbx-1",
+				fetchMailboxes: async () => [row("mbx-1", MailboxSyncStatus.failed)],
+				delay: noDelay,
+			}),
+			(error: unknown) =>
+				error instanceof Error && error.message === MAILBOX_SYNC_FAILED_MESSAGE,
+		);
+	});
+
+	it("rejects with the timeout message when the row never confirms", async () => {
+		let clock = 0;
+		let fetches = 0;
+		await assert.rejects(
+			waitForMailboxSynced({
+				mailboxId: "mbx-1",
+				fetchMailboxes: async () => {
+					fetches += 1;
+					return [row("mbx-1", MailboxSyncStatus.pending)];
+				},
+				timeoutMs: 30_000,
+				pollIntervalMs: 1_000,
+				now: () => clock,
+				delay: async (ms) => {
+					clock += ms;
+				},
+			}),
+			(error: unknown) =>
+				error instanceof Error &&
+				error.message === MAILBOX_SYNC_TIMEOUT_MESSAGE,
+		);
+		assert.ok(fetches > 1, "polls more than once before timing out");
+	});
+
+	it("does not treat failed as timeout even past the deadline", async () => {
+		let clock = 100_000;
+		await assert.rejects(
+			waitForMailboxSynced({
+				mailboxId: "mbx-1",
+				fetchMailboxes: async () => [row("mbx-1", MailboxSyncStatus.failed)],
+				timeoutMs: 1,
+				now: () => clock++,
+				delay: noDelay,
+			}),
+			(error: unknown) =>
+				error instanceof Error && error.message === MAILBOX_SYNC_FAILED_MESSAGE,
+		);
+	});
+
+	const isAbort = (error: unknown): boolean =>
+		typeof error === "object" &&
+		error !== null &&
+		(error as { name?: unknown }).name === "AbortError";
+
+	it("rejects without polling when the signal is already aborted", async () => {
+		const controller = new AbortController();
+		controller.abort();
+		let fetches = 0;
+		await assert.rejects(
+			waitForMailboxSynced({
+				mailboxId: "mbx-1",
+				signal: controller.signal,
+				fetchMailboxes: async () => {
+					fetches += 1;
+					return [row("mbx-1", MailboxSyncStatus.pending)];
+				},
+				delay: noDelay,
+			}),
+			isAbort,
+		);
+		assert.equal(fetches, 0);
+	});
+
+	it("stops polling and rejects when the signal aborts mid-wait", async () => {
+		const controller = new AbortController();
+		let fetches = 0;
+		await assert.rejects(
+			waitForMailboxSynced({
+				mailboxId: "mbx-1",
+				signal: controller.signal,
+				fetchMailboxes: async () => {
+					fetches += 1;
+					if (fetches === 2) controller.abort();
+					return [row("mbx-1", MailboxSyncStatus.pending)];
+				},
+				delay: noDelay,
+			}),
+			isAbort,
+		);
+		assert.equal(fetches, 2);
+	});
+
+	it("resolves across the real timer delay between polls", async () => {
+		const responses = [
+			[row("mbx-1", MailboxSyncStatus.pending)],
+			[row("mbx-1", MailboxSyncStatus.synced)],
+		];
+		let call = 0;
+		const result = await waitForMailboxSynced({
+			mailboxId: "mbx-1",
+			pollIntervalMs: 1,
+			fetchMailboxes: async () => responses[call++],
+		});
+		assert.equal(result.syncStatus, MailboxSyncStatus.synced);
+	});
+
+	it("aborts an in-progress real timer delay", async () => {
+		const controller = new AbortController();
+		const pending = waitForMailboxSynced({
+			mailboxId: "mbx-1",
+			signal: controller.signal,
+			pollIntervalMs: 10_000,
+			fetchMailboxes: async () => [row("mbx-1", MailboxSyncStatus.pending)],
+		});
+		setTimeout(() => controller.abort(), 5);
+		await assert.rejects(pending, isAbort);
+	});
+});

package/src/lib/mailbox-sync-wait.ts

@@ -0,0 +1,98 @@
+import { MailboxSyncStatus } from "@remit/domain-enums";
+
+type MailboxSyncStatusValue =
+	(typeof MailboxSyncStatus)[keyof typeof MailboxSyncStatus];
+
+/**
+ * A folder created for a dependent write — a filter that will move mail into it,
+ * or a move that lands mail there — is not usable the instant the create is
+ * queued: the row exists locally with `syncStatus: pending`, and the folder does
+ * not exist on the mail server until the imap-worker confirms the create and
+ * flips it to `synced`. Binding the dependent write to a `pending` row races the
+ * folder into existence across separate FIFO queues and cannot report a create
+ * that fails. This waits for the confirmation before the dependent write runs.
+ *
+ * The standalone create (a folder made in settings with no dependent write) does
+ * not use this — it may stay optimistic. The wait is only for the dependent case.
+ *
+ * The wait honours an `AbortSignal`: the surface that started the create passes
+ * one and aborts it on unmount/cancel/close, so a folder that confirms after the
+ * surface is gone never resolves and never fires the dependent bind or move.
+ */
+
+/** The read fields the wait needs off a mailbox row. */
+export interface MailboxSyncSignal {
+	mailboxId: string;
+	syncStatus?: MailboxSyncStatusValue;
+}
+
+export interface WaitForMailboxSyncedOptions<T extends MailboxSyncSignal> {
+	/** Reads the current mailbox rows; called once per poll (forces a fresh read). */
+	fetchMailboxes: () => Promise<readonly T[]>;
+	/** The row to wait on. */
+	mailboxId: string;
+	/** Aborts the wait; a late confirmation after abort resolves nothing. */
+	signal?: AbortSignal;
+	/** How long to wait for confirmation before giving up. */
+	timeoutMs?: number;
+	/** Gap between polls. */
+	pollIntervalMs?: number;
+	/** Injectable clock/sleep for tests. */
+	delay?: (ms: number, signal?: AbortSignal) => Promise<void>;
+	now?: () => number;
+}
+
+export const MAILBOX_SYNC_TIMEOUT_MS = 30_000;
+export const MAILBOX_SYNC_POLL_INTERVAL_MS = 1_000;
+
+export const MAILBOX_SYNC_FAILED_MESSAGE =
+	"The folder couldn't be created on the mail server. Please try again.";
+export const MAILBOX_SYNC_TIMEOUT_MESSAGE =
+	"The folder was created but the mail server hasn't confirmed it yet, so nothing was attached to it. It's in your folder list — try again in a moment.";
+
+const defaultDelay = (ms: number, signal?: AbortSignal): Promise<void> =>
+	new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason);
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+
+/**
+ * Resolve with the mailbox row once its `syncStatus` reaches `synced` — the
+ * server-confirmed row, carrying the path the server normalized the create to.
+ * Reject with a failure message when the create is reported `failed`, with a
+ * distinct timeout message when it never confirms within `timeoutMs`, and with
+ * the signal's reason (an `AbortError`) when `signal` aborts. A row that is still
+ * `pending` (or not yet in the list) keeps the poll running.
+ */
+export async function waitForMailboxSynced<T extends MailboxSyncSignal>({
+	fetchMailboxes,
+	mailboxId,
+	signal,
+	timeoutMs = MAILBOX_SYNC_TIMEOUT_MS,
+	pollIntervalMs = MAILBOX_SYNC_POLL_INTERVAL_MS,
+	delay = defaultDelay,
+	now = Date.now,
+}: WaitForMailboxSyncedOptions<T>): Promise<T> {
+	const deadline = now() + timeoutMs;
+	for (;;) {
+		signal?.throwIfAborted();
+		const mailboxes = await fetchMailboxes();
+		const mailbox = mailboxes.find((entry) => entry.mailboxId === mailboxId);
+		if (mailbox?.syncStatus === MailboxSyncStatus.synced) return mailbox;
+		if (mailbox?.syncStatus === MailboxSyncStatus.failed)
+			throw new Error(MAILBOX_SYNC_FAILED_MESSAGE);
+		if (now() >= deadline) throw new Error(MAILBOX_SYNC_TIMEOUT_MESSAGE);
+		await delay(pollIntervalMs, signal);
+	}
+}

package/src/lib/organize/filter-edit-model.test.ts

@@ -58,6 +58,16 @@ describe("filterToRule", () => {
 		assert.equal(rule.moveMailboxId, undefined);
 	});
 
+	it("loads a label action (issue #26)", () => {
+		const rule = filterToRule(filter({ actionLabelId: "lbl-1" }));
+		assert.equal(rule.labelId, "lbl-1");
+	});
+
+	it("maps the None label sentinel to no action", () => {
+		const rule = filterToRule(filter({ actionLabelId: "None" }));
+		assert.equal(rule.labelId, undefined);
+	});
+
 	it("loads a Temporary filter as an until-a-date rule", () => {
 		const rule = filterToRule(
 			filter({ scope: "Temporary", expiresAt: "2027-03-04T23:59:59+00:00" }),
@@ -131,6 +141,13 @@ describe("ruleChangesPredicateOrAction", () => {
 			true,
 		);
 	});
+
+	it("is true when the label target changes (issue #26)", () => {
+		assert.equal(
+			ruleChangesPredicateOrAction({ ...base, labelId: "lbl-new" }, base),
+			true,
+		);
+	});
 });
 
 describe("ruleChangesScopeOrExpiry (reader #266)", () => {
@@ -212,6 +229,27 @@ describe("buildUpdateFilterInput", () => {
 		assert.equal(body.actionMailboxId, "None");
 	});
 
+	it("sends a chosen label target (issue #26)", () => {
+		const changed: FilterRule = {
+			...original,
+			labelId: "lbl-receipts",
+			matchOperator: "any",
+		};
+		const body = buildUpdateFilterInput(changed, original);
+		assert.equal(body.actionLabelId, "lbl-receipts");
+	});
+
+	it("drops a cleared label target to the None sentinel", () => {
+		const withLabel = { ...original, labelId: "lbl-receipts" };
+		const changed = {
+			...withLabel,
+			labelId: undefined,
+			matchOperator: "any" as const,
+		};
+		const body = buildUpdateFilterInput(changed, withLabel);
+		assert.equal(body.actionLabelId, "None");
+	});
+
 	it("is empty when nothing changed", () => {
 		assert.deepEqual(buildUpdateFilterInput(original, original), {});
 	});

package/src/lib/organize/filter-edit-model.ts

@@ -14,8 +14,9 @@ import { NO_ACTION } from "./organize-model";
  * cannot evaluate it (D4) — the rule then matches by its literal clauses only.
  *
  * The scope maps `Standing` → "standing" and `Temporary` → "until"; a persisted
- * filter is never the one-time "once" scope. `moveMailboxId` drops the `"None"`
- * sentinel to `undefined` so an empty folder select reads as "no move action".
+ * filter is never the one-time "once" scope. `moveMailboxId` and `labelId` both
+ * drop the `"None"` sentinel to `undefined` so an empty select reads as "no
+ * action" (issue #26).
  */
 export const filterToRule = (
 	filter: RemitImapFilterResponse,
@@ -34,6 +35,8 @@ export const filterToRule = (
 			: undefined,
 		moveMailboxId:
 			filter.actionMailboxId !== NO_ACTION ? filter.actionMailboxId : undefined,
+		labelId:
+			filter.actionLabelId !== NO_ACTION ? filter.actionLabelId : undefined,
 		scope: filter.scope === "Temporary" ? "until" : "standing",
 		until:
 			filter.scope === "Temporary"
@@ -65,15 +68,16 @@ const predicateActionKey = (rule: FilterRule): string =>
 		clauses: rule.clauses.map((clause) => [clause.field, clause.value]),
 		operator: rule.matchOperator,
 		move: rule.moveMailboxId ?? null,
+		label: rule.labelId ?? null,
 		widen: rule.widen ? (rule.widen.inactive ? "inactive" : "active") : "none",
 	});
 
 /**
  * Whether the edited rule changes the predicate or the action versus the one it
- * was loaded from — the clauses, the match operator, the move target, or the
- * widen's presence. A change here is what bumps `ruleChangedAt` and offers the
- * re-back-apply (RFC 034 Decision 3.2); the name is deliberately excluded, so a
- * cosmetic rename is not a rule change.
+ * was loaded from — the clauses, the match operator, the move target, the
+ * label target, or the widen's presence. A change here is what bumps
+ * `ruleChangedAt` and offers the re-back-apply (RFC 034 Decision 3.2); the name
+ * is deliberately excluded, so a cosmetic rename is not a rule change.
  */
 export const ruleChangesPredicateOrAction = (
 	rule: FilterRule,
@@ -104,10 +108,10 @@ export const ruleChangesScopeOrExpiry = (
  * The PATCH body for an edited filter. A cosmetic rename sends `{ name }` only,
  * so the server's `changesRuleAssertion` guard leaves `ruleChangedAt`
  * untouched (RFC 034 Decision 3.2). A predicate or action change sends the
- * operator, clauses, and move target; a scope or expiry change sends `scope`
- * and, for the `until` scope, `expiresAt` (reader #266) — either bumps
- * `ruleChangedAt`. The label action and the anchor are never in the editor's
- * gift, so they never enter the patch; the partial update preserves them.
+ * operator, clauses, move target, and label target; a scope or expiry change
+ * sends `scope` and, for the `until` scope, `expiresAt` (reader #266) —
+ * either bumps `ruleChangedAt`. The anchor is never in the editor's gift, so
+ * it never enters the patch; the partial update preserves it.
  */
 export const buildUpdateFilterInput = (
 	rule: FilterRule,
@@ -123,6 +127,7 @@ export const buildUpdateFilterInput = (
 			value: clause.value,
 		}));
 		body.actionMailboxId = rule.moveMailboxId ?? NO_ACTION;
+		body.actionLabelId = rule.labelId ?? NO_ACTION;
 	}
 	if (ruleChangesScopeOrExpiry(rule, original)) {
 		body.scope = rule.scope === "until" ? "Temporary" : "Standing";

package/src/lib/organize/label-delete-copy.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { deleteLabelConfirmCopy } from "./label-delete-copy";
+
+describe("deleteLabelConfirmCopy", () => {
+	it("names the label with no blast-radius note when no filter uses it", () => {
+		const copy = deleteLabelConfirmCopy("Receipts", 0);
+		assert.equal(copy.title, 'Delete the "Receipts" label?');
+		assert.equal(copy.description, undefined);
+	});
+
+	it("names exactly one filter in the singular", () => {
+		const copy = deleteLabelConfirmCopy("Receipts", 1);
+		assert.match(copy.description ?? "", /1 filter that applies it/);
+	});
+
+	it("names several filters in the plural", () => {
+		const copy = deleteLabelConfirmCopy("Receipts", 3);
+		assert.match(copy.description ?? "", /3 filters that apply it/);
+	});
+});

package/src/lib/organize/label-delete-copy.ts

@@ -0,0 +1,22 @@
+/**
+ * The delete-confirmation copy for a label (issue #26). Deleting a label
+ * cascades in both directions server-side — every filter whose action applies
+ * it is deleted outright, never left dangling — so the confirmation names the
+ * filter count up front rather than surprising the user after the fact. The
+ * API itself never blocks the delete; the confirmation is the only gate.
+ */
+export const deleteLabelConfirmCopy = (
+	labelName: string,
+	filterCount: number,
+): { title: string; description?: string } => {
+	if (filterCount === 0) {
+		return { title: `Delete the "${labelName}" label?` };
+	}
+	const filterNoun = filterCount === 1 ? "filter" : "filters";
+	return {
+		title: `Delete the "${labelName}" label?`,
+		description: `This also deletes ${filterCount} ${filterNoun} that ${
+			filterCount === 1 ? "applies" : "apply"
+		} it — they can't be recovered.`,
+	};
+};

package/src/lib/organize/organize-model.test.ts

@@ -15,13 +15,15 @@ const baseDraft = (overrides: Partial<OrganizeDraft> = {}): OrganizeDraft => ({
 });
 
 describe("hasCommittableAction", () => {
-	it("is false when no move target is chosen — labeling has no backend yet, so a keep-in-place draft has nothing to commit", () => {
+	it("is false when neither a move nor a label is chosen — a keep-in-place draft has nothing to commit", () => {
 		assert.equal(hasCommittableAction(baseDraft()), false);
 	});
 
-	it("is false for the None sentinel", () => {
+	it("is false for the None sentinel on both actions", () => {
 		assert.equal(
-			hasCommittableAction(baseDraft({ moveMailboxId: NO_ACTION })),
+			hasCommittableAction(
+				baseDraft({ moveMailboxId: NO_ACTION, labelId: NO_ACTION }),
+			),
 			false,
 		);
 	});
@@ -32,10 +34,23 @@ describe("hasCommittableAction", () => {
 			true,
 		);
 	});
+
+	it("is true once a real label is chosen, with no move target (issue #26)", () => {
+		assert.equal(hasCommittableAction(baseDraft({ labelId: "lbl-1" })), true);
+	});
+
+	it("is true when both a move and a label are chosen", () => {
+		assert.equal(
+			hasCommittableAction(
+				baseDraft({ moveMailboxId: "mbx-1", labelId: "lbl-1" }),
+			),
+			true,
+		);
+	});
 });
 
 describe("buildOrganizeInput", () => {
-	it("carries the anchor and defaults the action to None when no move is set", () => {
+	it("carries the anchor and defaults both actions to None when neither is set", () => {
 		const input = buildOrganizeInput(baseDraft({ anchorMessageId: "msg-1" }));
 		assert.equal(input.anchorMessageId, "msg-1");
 		assert.equal(input.actionMailboxId, NO_ACTION);
@@ -53,12 +68,16 @@ describe("buildOrganizeInput", () => {
 		assert.equal("anchorMessageId" in input, false);
 	});
 
-	it("labels the label action None even when a move target is set — label writes have no endpoint", () => {
+	it("carries the move and label actions independently (issue #26)", () => {
 		const input = buildOrganizeInput(
-			baseDraft({ anchorMessageId: "msg-1", moveMailboxId: "mbx-9" }),
+			baseDraft({
+				anchorMessageId: "msg-1",
+				moveMailboxId: "mbx-9",
+				labelId: "lbl-9",
+			}),
 		);
 		assert.equal(input.actionMailboxId, "mbx-9");
-		assert.equal(input.actionLabelId, NO_ACTION);
+		assert.equal(input.actionLabelId, "lbl-9");
 	});
 });
 
@@ -101,4 +120,13 @@ describe("buildCreateFilterInput", () => {
 		);
 		assert.equal("ttl" in input, false);
 	});
+
+	it("carries a label action (issue #26)", () => {
+		const input = buildCreateFilterInput(
+			baseDraft({ labelId: "lbl-1" }),
+			"standing",
+			"Receipts",
+		);
+		assert.equal(input.actionLabelId, "lbl-1");
+	});
 });

package/src/lib/organize/organize-model.ts

@@ -27,9 +27,10 @@ export const NO_ACTION = "None";
 
 /**
  * The user's in-progress organize decision, independent of which scope they
- * land on. The anchor and predicate drive the match set; `moveMailboxId` is the
- * one committable action today (labeling has no backend yet — see
- * `labelPlaceholder`).
+ * land on. The anchor and predicate drive the match set; `moveMailboxId` and
+ * `labelId` are the two committable actions (issue #26) — independent of each
+ * other, since a move is exclusive and a label is additive (RFC 034 Decision
+ * 3.1).
  */
 export interface OrganizeDraft {
 	/** Semantic anchor — "mail like this one". The first selected message. */
@@ -43,6 +44,11 @@ export interface OrganizeDraft {
 	 * Decision 3.1). Absent means "keep where they are": no move action.
 	 */
 	moveMailboxId?: string;
+	/**
+	 * Label applied to the match set — the additive action (RFC 034 Decision
+	 * 3.1, issue #26). Absent applies no label.
+	 */
+	labelId?: string;
 	/**
 	 * ISO 8601 date-time with zone offset. Present only for the `temporary`
 	 * scope; a plain picked date (RFC 034 non-goal: no event-based expiry).
@@ -51,14 +57,13 @@ export interface OrganizeDraft {
 }
 
 /**
- * Whether the draft carries a committable action. Labeling is not wired yet
- * (no Label API — RFC 030's `Label`/`MessageLabel` entities exist in TypeSpec
- * but have no CRUD endpoint), so a move target is the only real action. A draft
- * with no move target has nothing to commit; the caller disables the CTA and
- * says why (ux.md).
+ * Whether the draft carries a committable action — a move destination and/or
+ * a label (issue #26), either satisfies this. A draft with neither has
+ * nothing to commit; the caller disables the CTA and says why (ux.md).
  */
 export const hasCommittableAction = (draft: OrganizeDraft): boolean =>
-	draft.moveMailboxId !== undefined && draft.moveMailboxId !== NO_ACTION;
+	(draft.moveMailboxId !== undefined && draft.moveMailboxId !== NO_ACTION) ||
+	(draft.labelId !== undefined && draft.labelId !== NO_ACTION);
 
 /**
  * Whether the draft's predicate can be back-applied over the existing corpus. A
@@ -75,7 +80,7 @@ export const canBackApplyDraft = (draft: OrganizeDraft): boolean =>
  * Build the read-only preview / back-apply matcher input. The action fields do
  * not affect which messages match — the preview returns exactly the set a job
  * with the same predicate would apply to — so a widen preview can pass this
- * before the user has chosen a folder.
+ * before the user has chosen a folder or a label.
  */
 export const buildOrganizeInput = (
 	draft: OrganizeDraft,
@@ -83,7 +88,7 @@ export const buildOrganizeInput = (
 	...(draft.anchorMessageId ? { anchorMessageId: draft.anchorMessageId } : {}),
 	matchOperator: draft.matchOperator,
 	literalClauses: draft.literalClauses,
-	actionLabelId: NO_ACTION,
+	actionLabelId: draft.labelId ?? NO_ACTION,
 	actionMailboxId: draft.moveMailboxId ?? NO_ACTION,
 });
 
@@ -107,7 +112,7 @@ export const buildCreateFilterInput = (
 			: {}),
 		matchOperator: draft.matchOperator,
 		literalClauses: draft.literalClauses,
-		actionLabelId: NO_ACTION,
+		actionLabelId: draft.labelId ?? NO_ACTION,
 		actionMailboxId: draft.moveMailboxId ?? NO_ACTION,
 		...(draft.anchorMessageId
 			? { anchorMessageId: draft.anchorMessageId }

package/src/lib/organize/rule-model.test.ts

@@ -247,6 +247,11 @@ describe("the previewed set equals the applied set", () => {
 			"mbx-archive",
 		);
 	});
+
+	it("carries the label target into the draft (issue #26)", () => {
+		const labeled = { ...semanticRule, labelId: "lbl-receipts" };
+		assert.equal(ruleToDraft(labeled, "msg-1").labelId, "lbl-receipts");
+	});
 });
 
 describe("derivePreview", () => {

package/src/lib/organize/rule-model.ts

@@ -164,6 +164,7 @@ export const ruleToDraft = (
 		matchOperator: predicate.matchOperator,
 		literalClauses: predicate.literalClauses,
 		moveMailboxId: rule.moveMailboxId,
+		labelId: rule.labelId,
 		expiresAt:
 			rule.scope === "until"
 				? pickedDateToExpiresAt(rule.until ?? "")