@remit/config-transfer 0.0.10 → 0.0.12

package/src/import.test.ts

@@ -6,7 +6,6 @@ import type {
 	AccountSettingItem,
 	AddressItem,
 	ConfigImportItem,
-	FilterAnchorItem,
 	FilterItem,
 	LabelItem,
 	MailboxItem,
@@ -17,7 +16,11 @@ import {
 	composeFolderRoleAppointmentName,
 } from "@remit/data-ports/folder-role";
 import { deriveAddressId } from "@remit/data-ports/id";
-import { bindImportedFolders, pendingImportOf } from "./binder.js";
+import {
+	bindImportedFolders,
+	disableFiltersMissingFolders,
+	pendingImportOf,
+} from "./binder.js";
 import { readConfigForExport } from "./export.js";
 import {
 	ACCOUNT_CONFIG_ID,
@@ -26,7 +29,6 @@ import {
 	makeAccount,
 	makeAccountConfig,
 	makeAddress,
-	makeAnchor,
 	makeFilter,
 	makeJunkOnlyFlaggedAddress,
 	makeLabel,
@@ -37,7 +39,7 @@ import {
 	PASSWORD_ACCOUNT_ID,
 	suggestable,
 } from "./fixtures.js";
-import { ANCHOR_EMBEDDING_PENDING, importConfig } from "./import.js";
+import { importConfig } from "./import.js";
 import type { ConfigImportDeps } from "./import-repositories.js";
 
 const IDENTITY = {
@@ -49,7 +51,6 @@ const IDENTITY = {
 
 const TARGET_CONFIG_ID = "1a2b3c4d5e6f7a8b9c0d1e2f3";
 const TARGET_USER_ID = "9f8e7d6c-5b4a-4938-8271-605f4e3d2c1b";
-const EMBEDDING_ID = "amazon.titan-embed-text-v2:0@1024";
 
 const INBOX_ID = "mbx-inbox";
 const SENT_ID = "mbx-sent";
@@ -70,7 +71,6 @@ interface Store {
 	mailboxes: MailboxItem[];
 	labels: LabelItem[];
 	filters: FilterItem[];
-	anchors: FilterAnchorItem[];
 	addresses: AddressItem[];
 	imports: ConfigImportItem[];
 	/** Set to make the next write of this kind fail, for the abort path. */
@@ -88,7 +88,6 @@ const emptyStore = (): Store => ({
 	mailboxes: [],
 	labels: [],
 	filters: [],
-	anchors: [],
 	addresses: [],
 	imports: [],
 });
@@ -104,7 +103,6 @@ const storeFromFixture = (fixture: ConfigFixture): Store => ({
 	mailboxes: [...fixture.mailboxes],
 	labels: [...fixture.labels],
 	filters: [...fixture.filters],
-	anchors: [...fixture.anchors],
 	addresses: [...fixture.addresses],
 	imports: [],
 });
@@ -185,6 +183,9 @@ const repositoriesOf = (store: Store, accountConfigId: string): any => {
 		mailbox: {
 			listAllByAccount: async (accountId: string) =>
 				store.mailboxes.filter((mailbox) => mailbox.accountId === accountId),
+			resolveAccountId: async (mailboxId: string) =>
+				store.mailboxes.find((mailbox) => mailbox.mailboxId === mailboxId)
+					?.accountId ?? null,
 		},
 		label: {
 			listByAccountConfig: async () => [...store.labels],
@@ -237,19 +238,6 @@ const repositoriesOf = (store: Store, accountConfigId: string): any => {
 				return next;
 			},
 		},
-		filterAnchor: {
-			put: async (input: Partial<FilterAnchorItem> & { filterId: string }) => {
-				const row = makeAnchor({ ...input, accountConfigId });
-				store.anchors = [
-					...store.anchors.filter(
-						(anchor) => anchor.filterId !== input.filterId,
-					),
-					row,
-				];
-				return row;
-			},
-			listByAccountConfig: async () => [...store.anchors],
-		},
 		address: {
 			// Both reads, so the stub can tell them apart: the suggest listing
 			// hides a junk-only row, and the import must not be reading it (#1029).
@@ -353,50 +341,47 @@ const appointFolderRoleInto =
 		);
 	};
 
-/**
- * A transaction that actually rolls back. The backend's `writeSet` discards
- * every write on a throw, so a fake that merely called through would let an
- * atomicity test pass over a store that had kept half a document — which is the
- * one thing these tests exist to catch. Each collection is restored to the
- * instance it had on entry.
- */
-const transactionOver =
+const createFolderInto =
 	(store: Store) =>
-	async <T>(run: () => Promise<T>): Promise<T> => {
-		const before = {
-			accountConfigs: new Map(store.accountConfigs),
-			accounts: [...store.accounts],
-			settings: new Map(store.settings),
-			mailboxes: [...store.mailboxes],
-			labels: [...store.labels],
-			filters: [...store.filters],
-			anchors: [...store.anchors],
-			addresses: [...store.addresses],
-			imports: [...store.imports],
-		};
-		return run().catch((error: unknown) => {
-			Object.assign(store, before);
-			throw error;
+	async (
+		accountId: string,
+		fullPath: string,
+	): Promise<{ outcome: "Created"; mailbox: MailboxItem }> => {
+		const row = makeMailbox({
+			mailboxId: nextId("mbx"),
+			accountId,
+			fullPath,
+			syncStatus: "pending",
 		});
+		store.mailboxes.push(row);
+		return { outcome: "Created", mailbox: row };
 	};
 
-const depsOf = (
+const settle = (
 	store: Store,
-	accountConfigId: string,
-	embed = true,
-): ConfigImportDeps => ({
+	fullPath: string,
+	syncStatus: MailboxItem["syncStatus"],
+	confirmedPath: string = fullPath,
+): MailboxItem => {
+	const at = store.mailboxes.findIndex(
+		(mailbox) =>
+			mailbox.fullPath === fullPath && mailbox.syncStatus === "pending",
+	);
+	assert.notEqual(at, -1, `no pending create for ${fullPath}`);
+	const next = { ...store.mailboxes[at], syncStatus, fullPath: confirmedPath };
+	store.mailboxes[at] = next;
+	return next;
+};
+
+const depsOf = (store: Store, accountConfigId: string): ConfigImportDeps => ({
 	repositories: repositoriesOf(store, accountConfigId),
 	appointFolderRole: appointFolderRoleInto(store),
-	transaction: transactionOver(store),
-	embedAnchor: embed
-		? async () => ({ embedding: [0.11, 0.22, 0.33], embeddingId: EMBEDDING_ID })
-		: undefined,
 	now: () => NOW,
 });
 
 // ---------------------------------------------------------------------------
 // A configuration worth carrying across: two accounts, both auth types, folder
-// roles, per-folder overrides, labels, a literal and a semantic filter, and two
+// roles, per-folder overrides, labels, two filters, and two
 // flagged senders.
 // ---------------------------------------------------------------------------
 
@@ -504,14 +489,12 @@ const sourceFixture = (): ConfigFixture => ({
 			actionMailboxId: INVOICES_ID,
 		}),
 		makeFilter({
-			filterId: "flt-semantic",
-			name: "Anything like this release note",
+			filterId: "flt-release",
+			name: "Release notes",
 			scope: "Temporary",
 			expiresAt: "2026-12-31T23:59:59+01:00",
-			hasAnchor: true,
 		}),
 	],
-	anchors: [makeAnchor({ filterId: "flt-semantic" })],
 	addresses: [
 		makeAddress({
 			addressId: "adr-bank",
@@ -602,6 +585,7 @@ test("a configuration survives an export, an import and a discovery unchanged",
 	const binder = {
 		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
 		appointFolderRole: appointFolderRoleInto(store),
+		createFolder: createFolderInto(store),
 		now: () => NOW,
 	};
 	await bindImportedFolders(binder, TARGET_CONFIG_ID, PASSWORD_ACCOUNT_ID);
@@ -828,7 +812,7 @@ test("a flag that arrives at the sentinel is stored at the sentinel", async () =
 	assert.equal(legacy?.flags?.category?.setAt, 0);
 });
 
-test("a folder no mailbox answers to yet is kept, then bound when discovery finds it", async () => {
+test("a folder discovery did not produce is created, and bound once the server confirms it", async () => {
 	const document = await exportSource();
 	const store = emptyStore();
 
@@ -849,6 +833,7 @@ test("a folder no mailbox answers to yet is kept, then bound when discovery find
 	const binder = {
 		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
 		appointFolderRole: appointFolderRoleInto(store),
+		createFolder: createFolderInto(store),
 		now: () => NOW,
 	};
 	const first = await bindImportedFolders(
@@ -858,6 +843,7 @@ test("a folder no mailbox answers to yet is kept, then bound when discovery find
 	);
 
 	assert.equal(first.bound > 0, true);
+	assert.equal(first.created, 2);
 	assert.equal(first.stillPending > 0, true);
 	const invoices = store.mailboxes.find(
 		(mailbox) => mailbox.fullPath === "INBOX.Facturen",
@@ -868,16 +854,28 @@ test("a folder no mailbox answers to yet is kept, then bound when discovery find
 		invoices?.mailboxId,
 	);
 
-	// Replayable: a second discovery over the same folders changes nothing.
+	// Replayable: a second discovery over the same folders creates nothing again.
 	const again = await bindImportedFolders(
 		binder,
 		TARGET_CONFIG_ID,
 		PASSWORD_ACCOUNT_ID,
 	);
 	assert.equal(again.bound, 0);
+	assert.equal(again.created, 0);
+	assert.equal(
+		store.mailboxes.filter((mailbox) => mailbox.fullPath === "INBOX.Sent")
+			.length,
+		1,
+	);
 	assert.equal(store.imports[0].state, "Pending");
 
-	discover(store, PASSWORD_ACCOUNT_ID, ["INBOX.Sent", "INBOX.Lists.dev-null"]);
+	settle(store, "INBOX.Sent", "synced");
+	const lists = settle(
+		store,
+		"INBOX.Lists.dev-null",
+		"synced",
+		"INBOX.Lists.dev-null-normalized",
+	);
 	discover(store, OAUTH_ACCOUNT_ID, ["INBOX"]);
 	await bindImportedFolders(binder, TARGET_CONFIG_ID, PASSWORD_ACCOUNT_ID);
 
@@ -890,15 +888,499 @@ test("a folder no mailbox answers to yet is kept, then bound when discovery find
 		)?.value.kind,
 		"String",
 	);
-	const lists = store.mailboxes.find(
-		(mailbox) => mailbox.fullPath === "INBOX.Lists.dev-null",
-	);
 	assert.equal(
-		store.settings.get(`MailboxDisplayName#${lists?.mailboxId}`)?.value.value,
+		store.settings.get(`MailboxDisplayName#${lists.mailboxId}`)?.value.value,
 		"dev/null",
 	);
 });
 
+test("a filter whose folder is missing lands disabled, awaiting the folder, and the report says so", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+
+	const report = reportOf(await apply(store, document));
+
+	const invoices = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(invoices?.state, "Disabled");
+	assert.equal(invoices?.disabledReason, "AwaitingFolder");
+	assert.match(
+		report.items.find((item) => item.key === "Invoices to Facturen")?.reason ??
+			"",
+		/Off until "INBOX\.Facturen" exists/,
+	);
+});
+
+test("the dry run names the filters an apply would leave off", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+
+	const outcome = await importConfig(depsOf(store, TARGET_CONFIG_ID), {
+		accountConfigId: TARGET_CONFIG_ID,
+		userId: TARGET_USER_ID,
+		document,
+		mode: "validate",
+		onExisting: "abort",
+	});
+
+	assert.match(
+		reportOf(outcome).items.find((item) => item.key === "Invoices to Facturen")
+			?.reason ?? "",
+		/Off until "INBOX\.Facturen" exists/,
+	);
+});
+
+test("an imported filter turns on once the folder the binder created settles, under the path the server chose", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+	await apply(store, document);
+
+	discover(store, PASSWORD_ACCOUNT_ID, ["INBOX", "INBOX.Sent"]);
+	const binder = {
+		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+		appointFolderRole: appointFolderRoleInto(store),
+		createFolder: createFolderInto(store),
+		now: () => NOW,
+	};
+	await bindImportedFolders(binder, TARGET_CONFIG_ID, PASSWORD_ACCOUNT_ID);
+
+	const waiting = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(waiting?.state, "Disabled");
+	assert.equal(waiting?.disabledReason, "AwaitingFolder");
+	assert.equal(waiting?.actionMailboxId, "None");
+
+	const created = settle(store, "INBOX.Facturen", "synced", "INBOX/Facturen");
+	await bindImportedFolders(binder, TARGET_CONFIG_ID, PASSWORD_ACCOUNT_ID);
+
+	const bound = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(bound?.state, "Active");
+	assert.equal(bound?.disabledReason, "None");
+	assert.equal(bound?.actionMailboxId, created.mailboxId);
+});
+
+test("a folder the server refused to create turns its filter off with FolderCreateFailed", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+	await apply(store, document);
+
+	discover(store, PASSWORD_ACCOUNT_ID, ["INBOX", "INBOX.Sent"]);
+	const binder = {
+		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+		appointFolderRole: appointFolderRoleInto(store),
+		createFolder: createFolderInto(store),
+		now: () => NOW,
+	};
+	await bindImportedFolders(binder, TARGET_CONFIG_ID, PASSWORD_ACCOUNT_ID);
+	settle(store, "INBOX.Facturen", "failed");
+
+	const result = await bindImportedFolders(
+		binder,
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+
+	assert.equal(result.disabled, 1);
+	const refused = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(refused?.state, "Disabled");
+	assert.equal(refused?.disabledReason, "FolderCreateFailed");
+	assert.equal(
+		pendingImportOf(store.imports)?.folderPaths.includes("INBOX.Facturen") ??
+			false,
+		false,
+	);
+});
+
+test("a created folder that disappears before it settles means the create never landed", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+	await apply(store, document);
+
+	discover(store, PASSWORD_ACCOUNT_ID, ["INBOX", "INBOX.Sent"]);
+	const binder = {
+		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+		appointFolderRole: appointFolderRoleInto(store),
+		createFolder: createFolderInto(store),
+		now: () => NOW,
+	};
+	await bindImportedFolders(binder, TARGET_CONFIG_ID, PASSWORD_ACCOUNT_ID);
+	store.mailboxes = store.mailboxes.filter(
+		(mailbox) => mailbox.fullPath !== "INBOX.Facturen",
+	);
+
+	const result = await bindImportedFolders(
+		binder,
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+
+	assert.equal(result.disabled, 1);
+	const refused = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(refused?.state, "Disabled");
+	assert.equal(refused?.disabledReason, "FolderCreateFailed");
+});
+
+test("a create that finds its path already taken binds the existing folder on the next sync", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+	await apply(store, document);
+
+	discover(store, PASSWORD_ACCOUNT_ID, ["INBOX", "INBOX.Sent"]);
+	const binder = {
+		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+		appointFolderRole: appointFolderRoleInto(store),
+		createFolder: async () => ({ outcome: "PathTaken" as const }),
+		now: () => NOW,
+	};
+	const first = await bindImportedFolders(
+		binder,
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+
+	assert.equal(first.created, 0);
+	assert.equal(
+		store.imports[0].unresolvedRefs.find(
+			(ref) => ref.folderPath === "INBOX.Facturen",
+		)?.mailboxId,
+		"None",
+	);
+
+	discover(store, PASSWORD_ACCOUNT_ID, ["INBOX.Facturen"]);
+	await bindImportedFolders(binder, TARGET_CONFIG_ID, PASSWORD_ACCOUNT_ID);
+
+	const existing = store.mailboxes.find(
+		(mailbox) => mailbox.fullPath === "INBOX.Facturen",
+	);
+	const bound = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(bound?.state, "Active");
+	assert.equal(bound?.actionMailboxId, existing?.mailboxId);
+});
+
+const withUnprefixedPaths = async () => {
+	const document = (await exportSource()) as unknown as {
+		accounts: {
+			folderRoles: { role: string; folderPath: string }[];
+		}[];
+		filters: { actionFolder: { folderPath: string } | null }[];
+	};
+	for (const filter of document.filters) {
+		if (filter.actionFolder?.folderPath === "INBOX.Facturen") {
+			filter.actionFolder.folderPath = "Facturen";
+		}
+	}
+	for (const account of document.accounts) {
+		for (const role of account.folderRoles) {
+			if (role.folderPath === "INBOX.Sent") role.folderPath = "Sent";
+		}
+	}
+	return document;
+};
+
+const discoverUnderInbox = (store: Store, paths: readonly string[]): void => {
+	for (const fullPath of ["INBOX", ...paths]) {
+		store.mailboxes.push(
+			makeMailbox({
+				mailboxId: nextId("mbx"),
+				accountId: PASSWORD_ACCOUNT_ID,
+				fullPath,
+				namespacePrefix: "INBOX.",
+			}),
+		);
+	}
+};
+
+test("a folder the account already holds under its namespace is bound, not created", async () => {
+	const store = emptyStore();
+	await apply(store, await withUnprefixedPaths());
+
+	discoverUnderInbox(store, ["INBOX.Facturen", "INBOX.Sent"]);
+	const result = await bindImportedFolders(
+		{
+			repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+			appointFolderRole: appointFolderRoleInto(store),
+			createFolder: createFolderInto(store),
+			now: () => NOW,
+		},
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+
+	const facturen = store.mailboxes.find(
+		(mailbox) => mailbox.fullPath === "INBOX.Facturen",
+	);
+	const sent = store.mailboxes.find(
+		(mailbox) => mailbox.fullPath === "INBOX.Sent",
+	);
+	assert.equal(
+		store.mailboxes.some((mailbox) => mailbox.fullPath === "Facturen"),
+		false,
+	);
+	assert.equal(result.disabled, 0);
+	const bound = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(bound?.state, "Active");
+	assert.equal(bound?.actionMailboxId, facturen?.mailboxId);
+	assert.equal(
+		store.settings.get(
+			composeFolderRoleAppointmentName(PASSWORD_ACCOUNT_ID, "Sent"),
+		)?.value.value,
+		sent?.mailboxId,
+	);
+});
+
+test("a created folder the worker folds into one the server already held binds to that one", async () => {
+	const store = emptyStore();
+	await apply(store, await withUnprefixedPaths());
+
+	discoverUnderInbox(store, ["INBOX.Sent"]);
+	const binder = {
+		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+		appointFolderRole: appointFolderRoleInto(store),
+		createFolder: createFolderInto(store),
+		now: () => NOW,
+	};
+	const first = await bindImportedFolders(
+		binder,
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+	assert.equal(first.created > 0, true);
+
+	store.mailboxes = store.mailboxes.filter(
+		(mailbox) => mailbox.fullPath !== "Facturen",
+	);
+	const holder = makeMailbox({
+		mailboxId: nextId("mbx"),
+		accountId: PASSWORD_ACCOUNT_ID,
+		fullPath: "INBOX.Facturen",
+		namespacePrefix: "INBOX.",
+	});
+	store.mailboxes.push(holder);
+
+	const second = await bindImportedFolders(
+		binder,
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+
+	assert.equal(second.disabled, 0);
+	const bound = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(bound?.state, "Active");
+	assert.equal(bound?.disabledReason, "None");
+	assert.equal(bound?.actionMailboxId, holder.mailboxId);
+});
+
+test("a filter the user pointed at a folder keeps it when the imported folder appears", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+	await apply(store, document);
+
+	const invoices = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.ok(invoices);
+	invoices.actionMailboxId = "mbx-picked";
+
+	discover(store, PASSWORD_ACCOUNT_ID, [
+		"INBOX",
+		"INBOX.Sent",
+		"INBOX.Facturen",
+	]);
+	await bindImportedFolders(
+		{
+			repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+			appointFolderRole: appointFolderRoleInto(store),
+			createFolder: createFolderInto(store),
+			now: () => NOW,
+		},
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+
+	const picked = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(picked?.actionMailboxId, "mbx-picked");
+	assert.equal(picked?.state, "Disabled");
+	assert.equal(picked?.disabledReason, "UserDisabled");
+	assert.equal(
+		store.imports[0].unresolvedRefs.some(
+			(ref) => ref.target === invoices.filterId,
+		),
+		false,
+	);
+});
+
+test("a filter the user already turned on with their own folder survives the import's failed create", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+	await apply(store, document);
+
+	discover(store, PASSWORD_ACCOUNT_ID, ["INBOX", "INBOX.Sent"]);
+	const binder = {
+		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+		appointFolderRole: appointFolderRoleInto(store),
+		createFolder: createFolderInto(store),
+		now: () => NOW,
+	};
+	await bindImportedFolders(binder, TARGET_CONFIG_ID, PASSWORD_ACCOUNT_ID);
+
+	const invoices = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.ok(invoices);
+	Object.assign(invoices, {
+		actionMailboxId: "mbx-picked",
+		state: "Active",
+		disabledReason: "None",
+	});
+	settle(store, "INBOX.Facturen", "failed");
+
+	const result = await bindImportedFolders(
+		binder,
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+
+	assert.equal(result.disabled, 0);
+	const kept = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(kept?.state, "Active");
+	assert.equal(kept?.actionMailboxId, "mbx-picked");
+});
+
+test("a failed rename of the created folder is not read as a failed create", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+	await apply(store, document);
+
+	discover(store, PASSWORD_ACCOUNT_ID, ["INBOX", "INBOX.Sent"]);
+	const binder = {
+		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+		appointFolderRole: appointFolderRoleInto(store),
+		createFolder: createFolderInto(store),
+		now: () => NOW,
+	};
+	await bindImportedFolders(binder, TARGET_CONFIG_ID, PASSWORD_ACCOUNT_ID);
+	const created = settle(store, "INBOX.Facturen", "failed");
+	Object.assign(created, { pendingPath: "INBOX.Invoices" });
+
+	const result = await bindImportedFolders(
+		binder,
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+
+	assert.equal(result.disabled, 0);
+	const waiting = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.equal(waiting?.disabledReason, "AwaitingFolder");
+	assert.equal(
+		store.imports[0].unresolvedRefs.some(
+			(ref) => ref.mailboxId === created.mailboxId,
+		),
+		true,
+	);
+});
+
+test("a folder still pending on the server is waited for, never bound", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+	await apply(store, document);
+
+	store.mailboxes.push(
+		makeMailbox({
+			mailboxId: nextId("mbx"),
+			accountId: PASSWORD_ACCOUNT_ID,
+			fullPath: "INBOX.Facturen",
+			syncStatus: "pending",
+		}),
+	);
+	discover(store, PASSWORD_ACCOUNT_ID, ["INBOX", "INBOX.Sent"]);
+	const result = await bindImportedFolders(
+		{
+			repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+			appointFolderRole: appointFolderRoleInto(store),
+			createFolder: createFolderInto(store),
+			now: () => NOW,
+		},
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+
+	assert.equal(
+		store.mailboxes.filter((mailbox) => mailbox.fullPath === "INBOX.Facturen")
+			.length,
+		1,
+	);
+	assert.equal(result.stillPending > 0, true);
+	assert.equal(
+		store.filters.find((filter) => filter.name === "Invoices to Facturen")
+			?.actionMailboxId,
+		"None",
+	);
+});
+
+test("a running filter whose folder another client deleted turns off with FolderMissing", async () => {
+	const store = emptyStore();
+	store.mailboxes.push(
+		makeMailbox({
+			mailboxId: INVOICES_ID,
+			accountId: PASSWORD_ACCOUNT_ID,
+			fullPath: "INBOX.Facturen",
+		}),
+	);
+	store.filters.push(
+		makeFilter({
+			filterId: "flt-live",
+			name: "Live",
+			actionMailboxId: INVOICES_ID,
+		}),
+		makeFilter({
+			filterId: "flt-gone",
+			name: "Gone",
+			actionMailboxId: LISTS_ID,
+		}),
+		makeFilter({
+			filterId: "flt-off",
+			name: "Off",
+			state: "Disabled",
+			disabledReason: "UserDisabled",
+			actionMailboxId: SENT_ID,
+		}),
+	);
+
+	const disabled = await disableFiltersMissingFolders(
+		repositoriesOf(store, TARGET_CONFIG_ID),
+		TARGET_CONFIG_ID,
+	);
+
+	assert.equal(disabled, 1);
+	const byId = new Map(
+		store.filters.map((filter) => [filter.filterId, filter]),
+	);
+	assert.equal(byId.get("flt-live")?.state, "Active");
+	assert.equal(byId.get("flt-gone")?.state, "Disabled");
+	assert.equal(byId.get("flt-gone")?.disabledReason, "FolderMissing");
+	assert.equal(byId.get("flt-off")?.disabledReason, "UserDisabled");
+});
+
 test("an import with no folders to wait for is complete the moment it lands", async () => {
 	const document = await exportSource();
 	const store = emptyStore();
@@ -1032,67 +1514,6 @@ test("a filter filing into an account the file does not carry is refused", async
 	assert.equal(report.errors[0]?.code, "unknown_account");
 });
 
-test("an anchor this deployment cannot embed is stored as text for the repair to pick up", async () => {
-	const document = await exportSource();
-	const store = emptyStore();
-
-	const outcome = await importConfig(depsOf(store, TARGET_CONFIG_ID, false), {
-		accountConfigId: TARGET_CONFIG_ID,
-		userId: TARGET_USER_ID,
-		document,
-		mode: "apply",
-		onExisting: "abort",
-	});
-	const report = reportOf(outcome);
-
-	const anchor = store.anchors[0];
-	assert.equal(anchor.anchorEmbeddingId, ANCHOR_EMBEDDING_PENDING);
-	assert.deepEqual(anchor.anchorEmbedding, []);
-	assert.equal(
-		anchor.anchorSourceText,
-		"the release note this filter was drawn from",
-	);
-	assert.equal(
-		report.warnings.some((warning) => warning.code === "anchor_not_embedded"),
-		true,
-	);
-});
-
-test("an embedder that fails costs the anchor its vector, not the import", async () => {
-	const document = await exportSource();
-	const store = emptyStore();
-	const deps = depsOf(store, TARGET_CONFIG_ID);
-
-	const report = reportOf(
-		await importConfig(
-			{
-				...deps,
-				embedAnchor: () => Promise.reject(new Error("embedder unavailable")),
-			},
-			{
-				accountConfigId: TARGET_CONFIG_ID,
-				userId: TARGET_USER_ID,
-				document,
-				mode: "apply",
-				onExisting: "abort",
-			},
-		),
-	);
-
-	assert.equal(report.applied, true);
-	assert.deepEqual(report.errors, []);
-	assert.equal(
-		report.warnings.some((warning) => warning.code === "anchor_not_embedded"),
-		true,
-	);
-	assert.equal(store.anchors[0]?.anchorEmbeddingId, ANCHOR_EMBEDDING_PENDING);
-	assert.equal(
-		store.anchors[0]?.anchorSourceText,
-		"the release note this filter was drawn from",
-	);
-	assert.equal(store.accounts.length > 0, true);
-});
-
 test("the dry run names the same folders and credentials the apply does", async () => {
 	const document = await exportSource();
 	const planStore = emptyStore();
@@ -1121,7 +1542,7 @@ test("the dry run names the same folders and credentials the apply does", async
 	assert.deepEqual(planStore.accounts, []);
 });
 
-test("a write that fails after validation leaves nothing behind and names where it stopped", async () => {
+test("a write that fails part-way reports what it did leave behind and names where it stopped", async () => {
 	const document = await exportSource();
 	const store = emptyStore();
 	store.failOn = "filter";
@@ -1129,40 +1550,8 @@ test("a write that fails after validation leaves nothing behind and names where
 	const report = reportOf(await apply(store, document));
 
 	assert.equal(report.valid, true);
-	assert.equal(report.applied, false);
 	assert.equal(report.errors[0]?.code, "import_write_failed");
 	assert.equal(report.errors[0]?.details?.section, "filters");
-	assert.match(report.errors[0]?.message ?? "", /Nothing was written/);
-	assert.equal(report.items[0]?.verdict, "rejected");
-
-	// Filters fail after accounts and labels have been written, so these are the
-	// assertions that make the claim: the rollback undid them too.
-	assert.deepEqual(store.imports, []);
-	assert.deepEqual(store.accounts, []);
-	assert.deepEqual(store.labels, []);
-	assert.deepEqual(store.filters, []);
-	assert.equal(store.accountConfigs.size, 0);
-});
-
-test("a write that fails without a transaction reports what it did leave behind", async () => {
-	const document = await exportSource();
-	const store = emptyStore();
-	store.failOn = "filter";
-
-	const deps = depsOf(store, TARGET_CONFIG_ID);
-	const report = reportOf(
-		await importConfig(
-			{ ...deps, transaction: undefined },
-			{
-				accountConfigId: TARGET_CONFIG_ID,
-				userId: TARGET_USER_ID,
-				document,
-				mode: "apply",
-				onExisting: "abort",
-			},
-		),
-	);
-
 	assert.equal(report.applied, true);
 	assert.match(report.errors[0]?.message ?? "", /were written and remain/);
 	assert.equal(
@@ -1174,6 +1563,29 @@ test("a write that fails without a transaction reports what it did leave behind"
 	assert.equal(store.accounts.length > 0, true);
 });
 
+test("a stopped import imported again with merge reaches what one clean import holds", async () => {
+	const document = await exportSource();
+	const clean = emptyStore();
+	await apply(clean, document);
+
+	const store = emptyStore();
+	store.failOn = "filter";
+	await apply(store, document);
+	store.failOn = undefined;
+	const report = reportOf(await apply(store, document, "merge"));
+
+	assert.deepEqual(report.errors, []);
+	const held = (target: Store) => ({
+		accounts: target.accounts.map((account) => account.email).sort(),
+		labels: target.labels.map((label) => label.name).sort(),
+		filters: target.filters.length,
+		addresses: target.addresses.length,
+		settings: [...target.settings.keys()].sort(),
+	});
+	assert.deepEqual(held(store), held(clean));
+	assert.ok(held(clean).filters > 0, "the file carries filters to land");
+});
+
 test("the configuration row is created when the database holds none, and named from the file", async () => {
 	const document = await exportSource();
 	const store = emptyStore();
@@ -1226,12 +1638,19 @@ test("a binder run on a configuration with no import does nothing", async () =>
 		{
 			repositories: repositoriesOf(store, TARGET_CONFIG_ID),
 			appointFolderRole: appointFolderRoleInto(store),
+			createFolder: createFolderInto(store),
 			now: () => NOW,
 		},
 		TARGET_CONFIG_ID,
 		PASSWORD_ACCOUNT_ID,
 	);
-	assert.deepEqual(result, { bound: 0, dropped: 0, stillPending: 0 });
+	assert.deepEqual(result, {
+		bound: 0,
+		dropped: 0,
+		created: 0,
+		disabled: 0,
+		stillPending: 0,
+	});
 	assert.equal(pendingImportOf([]), undefined);
 });
 
@@ -1258,6 +1677,7 @@ test("a filter deleted before its folder is discovered drops its reference inste
 	const binder = {
 		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
 		appointFolderRole: appointFolderRoleInto(store),
+		createFolder: createFolderInto(store),
 		now: () => NOW,
 	};
 
@@ -1282,7 +1702,13 @@ test("a filter deleted before its folder is discovered drops its reference inste
 		TARGET_CONFIG_ID,
 		PASSWORD_ACCOUNT_ID,
 	);
-	assert.deepEqual(again, { bound: 0, dropped: 0, stillPending: 0 });
+	assert.deepEqual(again, {
+		bound: 0,
+		dropped: 0,
+		created: 0,
+		disabled: 0,
+		stillPending: 0,
+	});
 });
 
 test("a deleted filter's reference is dropped even when its folder never appears", async () => {
@@ -1303,6 +1729,7 @@ test("a deleted filter's reference is dropped even when its folder never appears
 		{
 			repositories: repositoriesOf(store, TARGET_CONFIG_ID),
 			appointFolderRole: appointFolderRoleInto(store),
+			createFolder: createFolderInto(store),
 			now: () => NOW,
 		},
 		TARGET_CONFIG_ID,