@remit/config-transfer 0.0.10 → 0.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/config-transfer",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/binder.ts

@@ -1,17 +1,24 @@
 import { readConfigDocument } from "@remit/config-format";
-import type {
-	ConfigImportItem,
-	ConfigImportUnresolvedRefItem,
-	IAccountSettingRepository,
-	IConfigImportRepository,
-	IFilterRepository,
-	IMailboxRepository,
+import {
+	type ConfigImportItem,
+	type ConfigImportUnresolvedRefItem,
+	type CreateMailboxResult,
+	FILTER_NO_ACTION,
+	type FilterItem,
+	type IAccountSettingRepository,
+	type IConfigImportRepository,
+	type IFilterRepository,
+	type IMailboxRepository,
+	type MailboxItem,
 } from "@remit/data-ports";
 import { composeSettingName } from "@remit/data-ports/account-settings";
 import {
 	AccountSettingName,
 	ConfigImportRefKind,
 	ConfigImportState,
+	FilterDisabledReason,
+	FilterState,
+	MailboxSyncStatus,
 } from "@remit/domain-enums";
 import type { AppointFolderRole } from "./import-repositories.js";
 
@@ -19,12 +26,18 @@ export interface ConfigBinderRepositories {
 	configImport: Pick<IConfigImportRepository, "listByAccountConfig" | "update">;
 	accountSetting: Pick<IAccountSettingRepository, "upsert">;
 	filter: Pick<IFilterRepository, "listByAccountConfig" | "update">;
-	mailbox: Pick<IMailboxRepository, "listAllByAccount">;
+	mailbox: Pick<IMailboxRepository, "listAllByAccount" | "resolveAccountId">;
 }
 
+export type CreateImportedFolder = (
+	accountId: string,
+	folderPath: string,
+) => Promise<CreateMailboxResult>;
+
 export interface ConfigBinderDeps {
 	repositories: ConfigBinderRepositories;
 	appointFolderRole: AppointFolderRole;
+	createFolder: CreateImportedFolder;
 	now?: () => number;
 }
 
@@ -35,27 +48,34 @@ export interface ConfigBinderDeps {
 export interface BindResult {
 	bound: number;
 	dropped: number;
+	created: number;
+	disabled: number;
 	stillPending: number;
 }
 
 type RefState =
 	| { kind: "TargetGone" }
-	| { kind: "Waiting" }
-	| { kind: "Ready"; mailboxId: string };
+	| { kind: "Waiting"; mailboxId: string }
+	| { kind: "Ready"; mailboxId: string }
+	| { kind: "Absent" }
+	| { kind: "Refused"; reason: FilterItem["disabledReason"] };
 
 /**
  * Bind the folder references an import could not resolve, now that discovery
  * has produced this account's mailboxes.
  *
  * Every reference names a folder by IMAP path, because the ids are new on every
- * discovery. This runs where discovery ends, resolves what it can, writes the
- * row each reference belongs to, and drops it. An import whose last reference
- * is gone is Complete; the rest stay, and surface on `GET /config` until the
- * folder they name shows up or the person removes the expectation.
+ * discovery. A path discovery did not produce is a folder the account lacks,
+ * so the binder creates it through the folder-create mutation and waits for
+ * the server to confirm it (imap-mutations R1, R2: wait), binding to that row
+ * by id because the server may have normalized its path. A create the server
+ * refused, or a created folder that vanished, drops the reference and turns
+ * its filter off with the reason.
  *
  * Idempotent and replayable: every write is an upsert or an update onto a row
- * the import already created, so a second discovery finds nothing to do rather
- * than doing it again differently.
+ * the import already created, and a create is recorded on the reference before
+ * the next run, so a second discovery finds nothing to do rather than doing it
+ * again differently.
  */
 export const bindImportedFolders = async (
 	deps: ConfigBinderDeps,
@@ -64,48 +84,108 @@ export const bindImportedFolders = async (
 ): Promise<BindResult> => {
 	const { repositories } = deps;
 	const now = deps.now ?? Date.now;
+	const result: BindResult = {
+		bound: 0,
+		dropped: 0,
+		created: 0,
+		disabled: 0,
+		stillPending: 0,
+	};
 
 	const imports = (
 		await repositories.configImport.listByAccountConfig(accountConfigId)
 	).filter((row) => row.state === ConfigImportState.Pending);
-	if (imports.length === 0) return { bound: 0, dropped: 0, stillPending: 0 };
+	if (imports.length === 0) return result;
 
+	const mailboxes = await repositories.mailbox.listAllByAccount(accountId);
 	const byPath = new Map(
-		(await repositories.mailbox.listAllByAccount(accountId)).map(
-			(mailbox) => [mailbox.fullPath, mailbox.mailboxId] as const,
-		),
+		mailboxes.map((mailbox) => [mailbox.fullPath, mailbox] as const),
+	);
+	const byId = new Map(
+		mailboxes.map((mailbox) => [mailbox.mailboxId, mailbox] as const),
 	);
 
-	const filterIds = new Set(
+	const filtersById = new Map(
 		(await repositories.filter.listByAccountConfig(accountConfigId)).map(
-			(filter) => filter.filterId,
+			(filter) => [filter.filterId, filter] as const,
 		),
 	);
 
-	let bound = 0;
-	let dropped = 0;
-	let stillPending = 0;
+	const createdByPath = new Map<string, string>();
+	const createFolder = async (folderPath: string): Promise<string> => {
+		const held = createdByPath.get(folderPath);
+		if (held !== undefined) return held;
+		const created = await deps.createFolder(accountId, folderPath);
+		if (created.outcome === "PathTaken") return FILTER_NO_ACTION;
+		createdByPath.set(folderPath, created.mailbox.mailboxId);
+		result.created++;
+		return created.mailbox.mailboxId;
+	};
 
 	for (const row of imports) {
 		const document = readConfigDocument(row.document);
 		const remaining: ConfigImportUnresolvedRefItem[] = [];
+		let changed = false;
 
 		for (const ref of row.unresolvedRefs) {
-			const state = refStateOf(ref, accountId, byPath, filterIds);
+			const state = refStateOf(ref, accountId, byPath, byId, filtersById);
+			if (
+				(state.kind === "Ready" || state.kind === "Refused") &&
+				!movesIntoNothing(ref, filtersById)
+			) {
+				await settlePickedFolder(
+					repositories,
+					accountConfigId,
+					filtersById.get(ref.target),
+				);
+				result.dropped++;
+				changed = true;
+				continue;
+			}
 			if (state.kind === "TargetGone") {
-				dropped++;
+				result.dropped++;
+				changed = true;
 				continue;
 			}
 			if (state.kind === "Waiting") {
-				remaining.push(ref);
+				if (state.mailboxId !== ref.mailboxId) changed = true;
+				remaining.push({ ...ref, mailboxId: state.mailboxId });
 				continue;
 			}
-			await bindRef(deps, accountConfigId, ref, state.mailboxId, document);
-			bound++;
+			if (state.kind === "Absent") {
+				remaining.push({
+					...ref,
+					mailboxId: await createFolder(ref.folderPath),
+				});
+				changed = true;
+				continue;
+			}
+			if (state.kind === "Refused") {
+				if (ref.kind === ConfigImportRefKind.FilterAction) {
+					await repositories.filter.update(accountConfigId, ref.target, {
+						state: FilterState.Disabled,
+						disabledReason: state.reason,
+					});
+					result.disabled++;
+				}
+				result.dropped++;
+				changed = true;
+				continue;
+			}
+			await bindRef(
+				deps,
+				accountConfigId,
+				ref,
+				state.mailboxId,
+				document,
+				filtersById,
+			);
+			result.bound++;
+			changed = true;
 		}
 
-		stillPending += remaining.length;
-		if (remaining.length === row.unresolvedRefs.length) continue;
+		result.stillPending += remaining.length;
+		if (!changed) continue;
 
 		await repositories.configImport.update(row.importId, {
 			unresolvedRefs: remaining,
@@ -115,27 +195,116 @@ export const bindImportedFolders = async (
 		});
 	}
 
-	return { bound, dropped, stillPending };
+	return result;
+};
+
+export const disableFiltersMissingFolders = async (
+	repositories: {
+		filter: Pick<IFilterRepository, "listByAccountConfig" | "update">;
+		mailbox: Pick<IMailboxRepository, "resolveAccountId">;
+	},
+	accountConfigId: string,
+): Promise<number> => {
+	const filters =
+		await repositories.filter.listByAccountConfig(accountConfigId);
+	let disabled = 0;
+	for (const filter of filters) {
+		if (filter.state !== FilterState.Active) continue;
+		if (filter.actionMailboxId === FILTER_NO_ACTION) continue;
+		const owner = await repositories.mailbox.resolveAccountId(
+			filter.actionMailboxId,
+		);
+		if (owner !== null) continue;
+		await repositories.filter.update(accountConfigId, filter.filterId, {
+			state: FilterState.Disabled,
+			disabledReason: FilterDisabledReason.FolderMissing,
+		});
+		disabled++;
+	}
+	return disabled;
 };
 
 type BoundDocument = ReturnType<typeof readConfigDocument>;
 
+const FOLDERLESS_REASONS: ReadonlySet<FilterItem["disabledReason"]> = new Set([
+	FilterDisabledReason.AwaitingFolder,
+	FilterDisabledReason.FolderCreateFailed,
+]);
+
+const settlePickedFolder = async (
+	repositories: ConfigBinderRepositories,
+	accountConfigId: string,
+	filter: FilterItem | undefined,
+): Promise<void> => {
+	if (!filter || filter.state !== FilterState.Disabled) return;
+	if (!FOLDERLESS_REASONS.has(filter.disabledReason)) return;
+	await repositories.filter.update(accountConfigId, filter.filterId, {
+		disabledReason: FilterDisabledReason.UserDisabled,
+	});
+};
+
+const movesIntoNothing = (
+	ref: ConfigImportUnresolvedRefItem,
+	filtersById: ReadonlyMap<string, FilterItem>,
+): boolean =>
+	ref.kind !== ConfigImportRefKind.FilterAction ||
+	filtersById.get(ref.target)?.actionMailboxId === FILTER_NO_ACTION;
+
+const findByPath = (
+	folderPath: string,
+	byPath: ReadonlyMap<string, MailboxItem>,
+): MailboxItem | undefined => {
+	const exact = byPath.get(folderPath);
+	if (exact) return exact;
+	const prefix = byPath.get("INBOX")?.namespacePrefix ?? "";
+	if (prefix === "" || folderPath.startsWith(prefix)) return undefined;
+	return byPath.get(`${prefix}${folderPath}`);
+};
+
 const refStateOf = (
 	ref: ConfigImportUnresolvedRefItem,
 	accountId: string,
-	byPath: ReadonlyMap<string, string>,
-	filterIds: ReadonlySet<string>,
+	byPath: ReadonlyMap<string, MailboxItem>,
+	byId: ReadonlyMap<string, MailboxItem>,
+	filtersById: ReadonlyMap<string, FilterItem>,
 ): RefState => {
 	if (
 		ref.kind === ConfigImportRefKind.FilterAction &&
-		!filterIds.has(ref.target)
+		!filtersById.has(ref.target)
 	) {
 		return { kind: "TargetGone" };
 	}
-	const mailboxId =
-		ref.accountId === accountId ? byPath.get(ref.folderPath) : undefined;
-	if (mailboxId === undefined) return { kind: "Waiting" };
-	return { kind: "Ready", mailboxId };
+	if (ref.accountId !== accountId) {
+		return { kind: "Waiting", mailboxId: ref.mailboxId };
+	}
+	const created = byId.get(ref.mailboxId);
+	if (created) {
+		if (created.syncStatus === MailboxSyncStatus.synced) {
+			return { kind: "Ready", mailboxId: created.mailboxId };
+		}
+		if (
+			created.syncStatus === MailboxSyncStatus.failed &&
+			created.pendingPath === undefined
+		) {
+			return {
+				kind: "Refused",
+				reason: FilterDisabledReason.FolderCreateFailed,
+			};
+		}
+		return { kind: "Waiting", mailboxId: created.mailboxId };
+	}
+	const found = findByPath(ref.folderPath, byPath);
+	if (found?.syncStatus === MailboxSyncStatus.synced) {
+		return { kind: "Ready", mailboxId: found.mailboxId };
+	}
+	if (found) return { kind: "Waiting", mailboxId: FILTER_NO_ACTION };
+	if (ref.mailboxId !== FILTER_NO_ACTION) {
+		return {
+			kind: "Refused",
+			reason: FilterDisabledReason.FolderCreateFailed,
+		};
+	}
+	return { kind: "Absent" };
 };
 
 const bindRef = async (
@@ -144,11 +313,21 @@ const bindRef = async (
 	ref: ConfigImportUnresolvedRefItem,
 	mailboxId: string,
 	document: BoundDocument,
+	filtersById: ReadonlyMap<string, FilterItem>,
 ): Promise<void> => {
 	const { repositories } = deps;
 	if (ref.kind === ConfigImportRefKind.FilterAction) {
+		const awaiting =
+			filtersById.get(ref.target)?.disabledReason ===
+			FilterDisabledReason.AwaitingFolder;
 		await repositories.filter.update(accountConfigId, ref.target, {
 			actionMailboxId: mailboxId,
+			...(awaiting
+				? {
+						state: FilterState.Active,
+						disabledReason: FilterDisabledReason.None,
+					}
+				: {}),
 		});
 		return;
 	}

package/src/export.test.ts

@@ -16,7 +16,6 @@ import {
 	makeAccount,
 	makeAccountConfig,
 	makeAddress,
-	makeAnchor,
 	makeFilter,
 	makeJunkOnlyFlaggedAddress,
 	makeLabel,
@@ -158,14 +157,12 @@ const fullFixture = (): 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",
@@ -195,12 +192,12 @@ const fullFixture = (): ConfigFixture => ({
 const exportFixture = (fixture: ConfigFixture) =>
 	readConfigForExport(asRepositories(fixture), ACCOUNT_CONFIG_ID, IDENTITY);
 
-test("a configuration exports as a document the v1 schema accepts", async () => {
+test("a configuration exports as a document the current schema accepts", async () => {
 	const document = await exportFixture(fullFixture());
 
 	assert.equal(ReaderConfigDocumentSchema.safeParse(document).success, true);
 	assert.equal(document.kind, "reader.config");
-	assert.equal(document.schemaVersion, 1);
+	assert.equal(document.schemaVersion, 2);
 	assert.deepEqual(document.provenance, {
 		accountConfigId: ACCOUNT_CONFIG_ID,
 		instance: "reader.ischen.nl",
@@ -379,7 +376,7 @@ test("an override on a folder that no longer exists is dropped", async () => {
 
 test("a filter names its label and its folder, never their ids", async () => {
 	const document = await exportFixture(fullFixture());
-	const [invoices, semantic] = document.filters;
+	const [invoices, release] = document.filters;
 
 	assert.equal(invoices?.actionLabelName, "Facturen");
 	assert.equal(invoices?.matchOperator, "Or");
@@ -388,11 +385,10 @@ test("a filter names its label and its folder, never their ids", async () => {
 		{ field: "FromDomain", value: "moneybird.com" },
 	]);
 	assert.equal(invoices?.expiresAt, null);
-	assert.equal(invoices?.anchor, null);
 
-	assert.equal(semantic?.actionLabelName, null);
-	assert.equal(semantic?.actionFolder, null);
-	assert.equal(semantic?.expiresAt, "2026-12-31T23:59:59+01:00");
+	assert.equal(release?.actionLabelName, null);
+	assert.equal(release?.actionFolder, null);
+	assert.equal(release?.expiresAt, "2026-12-31T23:59:59+01:00");
 });
 
 test("a filter action naming something that is gone exports as no action", async () => {
@@ -408,31 +404,6 @@ test("a filter action naming something that is gone exports as no action", async
 	assert.equal(document.filters[0]?.actionFolder, null);
 });
 
-test("an anchor exports its text and its provenance, never its vector", async () => {
-	const document = await exportFixture(fullFixture());
-
-	assert.deepEqual(document.filters[1]?.anchor, {
-		sourceText: "the release note this filter was drawn from",
-		embeddingId: "amazon.titan-embed-text-v2:0@1024",
-		sourceMessageId: "2c9e4b117d5a4f609a315b8c0",
-	});
-	assert.equal(JSON.stringify(document).includes("anchorEmbedding"), false);
-	assert.equal(JSON.stringify(document).includes("0.22"), false);
-});
-
-test("a filter claiming an anchor it has no row for exports without one", async () => {
-	// hasAnchor is a cache of whether the sibling row exists, and a write that
-	// failed after the filter landed leaves it saying yes over nothing. The
-	// export answers with the rows it can read, never with the flag.
-	const fixture = fullFixture();
-	fixture.anchors = [];
-
-	const document = await exportFixture(fixture);
-
-	assert.equal(document.filters[1]?.anchor, null);
-	assert.equal(ReaderConfigDocumentSchema.safeParse(document).success, true);
-});
-
 test("labels export by name and colour", async () => {
 	const document = await exportFixture(fullFixture());
 
@@ -625,7 +596,6 @@ test("a configuration with nothing in it still exports a valid document", async
 		mailboxes: [],
 		labels: [],
 		filters: [],
-		anchors: [],
 		addresses: [],
 	});
 

package/src/export.ts

@@ -14,7 +14,6 @@ import type {
 	AccountItem,
 	AddressFlags,
 	AddressItem,
-	FilterAnchorItem,
 	FilterItem,
 	LabelItem,
 	MailboxItem,
@@ -245,7 +244,6 @@ const toConfigLabel = (label: LabelItem): ConfigLabel => ({
 
 const toConfigFilter = (
 	filter: FilterItem,
-	anchor: FilterAnchorItem | undefined,
 	labelNames: ReadonlyMap<string, string>,
 	index: MailboxIndex,
 ): ConfigFilter => {
@@ -274,16 +272,6 @@ const toConfigFilter = (
 			actionAccountId === undefined || actionPath === undefined
 				? null
 				: { accountId: actionAccountId, folderPath: actionPath },
-		// The stored vector is a function of the model that produced it, so it
-		// means nothing on an instance running another one. The source text is
-		// what travels; import re-embeds from it.
-		anchor: anchor
-			? {
-					sourceText: anchor.anchorSourceText,
-					embeddingId: anchor.anchorEmbeddingId,
-					sourceMessageId: anchor.anchorMessageId,
-				}
-			: null,
 	};
 };
 
@@ -378,7 +366,7 @@ export const readConfigForExport = async (
 	accountConfigId: string,
 	identity: ConfigExportIdentity,
 ): Promise<ReaderConfigDocument> => {
-	const [accountConfig, accounts, settingRows, labels, filters, anchors] =
+	const [accountConfig, accounts, settingRows, labels, filters] =
 		await Promise.all([
 			// A configuration nobody has added an account to yet holds no row. That
 			// is an empty export, not a failure: the file is the migration safety
@@ -393,7 +381,6 @@ export const readConfigForExport = async (
 			repositories.accountSetting.listByAccountConfig(accountConfigId),
 			repositories.label.listByAccountConfig(accountConfigId),
 			repositories.filter.listByAccountConfig(accountConfigId),
-			repositories.filterAnchor.listByAccountConfig(accountConfigId),
 		]);
 
 	const liveAccounts = accounts.filter(
@@ -415,9 +402,6 @@ export const readConfigForExport = async (
 	const labelNames = new Map(
 		labels.map((label) => [label.labelId, label.name] as const),
 	);
-	const anchorsByFilter = new Map(
-		anchors.map((anchor) => [anchor.filterId, anchor] as const),
-	);
 	const addresses = await readAddresses(repositories, accountConfigId);
 
 	const document: ReaderConfigDocument = {
@@ -448,14 +432,7 @@ export const readConfigForExport = async (
 			),
 		),
 		labels: labels.map(toConfigLabel),
-		filters: filters.map((filter) =>
-			toConfigFilter(
-				filter,
-				anchorsByFilter.get(filter.filterId),
-				labelNames,
-				index,
-			),
-		),
+		filters: filters.map((filter) => toConfigFilter(filter, labelNames, index)),
 		addressFlags: addresses
 			.filter((address) => carriesUserFlag(address.flags))
 			.map(toConfigAddressFlags),

package/src/fixtures.ts

@@ -3,7 +3,6 @@ import type {
 	AccountItem,
 	AccountSettingItem,
 	AddressItem,
-	FilterAnchorItem,
 	FilterItem,
 	IAddressRepository,
 	LabelItem,
@@ -24,7 +23,6 @@ export interface ConfigFixture {
 	mailboxes: MailboxItem[];
 	labels: LabelItem[];
 	filters: FilterItem[];
-	anchors: FilterAnchorItem[];
 	addresses: AddressItem[];
 	/** Page size for the address listing, so paging is exercised. */
 	addressPageSize?: number;
@@ -129,11 +127,11 @@ export const makeFilter = (
 	accountConfigId: ACCOUNT_CONFIG_ID,
 	scope: "Standing",
 	state: "Active",
-	hasAnchor: false,
+	disabledReason: "None",
 	ruleChangedAt: NOW,
 	actionChangedAt: NOW,
 	matchOperator: "And",
-	literalClauses: [],
+	literalClauses: [{ field: "Subject", value: "release notes" }],
 	actionLabelId: "None",
 	actionMailboxId: "None",
 	createdAt: NOW,
@@ -141,19 +139,6 @@ export const makeFilter = (
 	...overrides,
 });
 
-export const makeAnchor = (
-	overrides: Partial<FilterAnchorItem> & Pick<FilterAnchorItem, "filterId">,
-): FilterAnchorItem => ({
-	accountConfigId: ACCOUNT_CONFIG_ID,
-	anchorEmbedding: [0.11, 0.22, 0.33],
-	anchorEmbeddingId: "amazon.titan-embed-text-v2:0@1024",
-	anchorSourceText: "the release note this filter was drawn from",
-	anchorMessageId: "2c9e4b117d5a4f609a315b8c0",
-	createdAt: NOW,
-	updatedAt: NOW,
-	...overrides,
-});
-
 export const makeAddress = (
 	overrides: Partial<AddressItem> &
 		Pick<AddressItem, "addressId" | "normalizedEmail">,
@@ -286,8 +271,5 @@ export const asRepositories = (
 	filter: {
 		listByAccountConfig: async () => fixture.filters,
 	},
-	filterAnchor: {
-		listByAccountConfig: async () => fixture.anchors,
-	},
 	address: asAddressRepository(fixture),
 });

package/src/import-repositories.ts

@@ -5,7 +5,6 @@ import type {
 	IAccountSettingRepository,
 	IAddressRepository,
 	IConfigImportRepository,
-	IFilterAnchorRepository,
 	IFilterRepository,
 	ILabelRepository,
 	IMailboxRepository,
@@ -38,7 +37,6 @@ export interface ConfigImportRepositories {
 	mailbox: Pick<IMailboxRepository, "listAllByAccount">;
 	label: Pick<ILabelRepository, "listByAccountConfig" | "create" | "update">;
 	filter: Pick<IFilterRepository, "listByAccountConfig" | "create" | "update">;
-	filterAnchor: Pick<IFilterAnchorRepository, "put">;
 	/**
 	 * Not the suggest listing, for the reason the export refuses it too: what a
 	 * configuration already holds is decided over every stored row, junk-only
@@ -54,21 +52,6 @@ export interface ConfigImportRepositories {
 	>;
 }
 
-/**
- * A filter anchor, re-embedded from the source text the file carries. The
- * stored vector is a function of the model that produced it, so it never
- * travels; this is the one thing an import has to compute rather than copy.
- *
- * Optional, and free to answer `undefined`, because a configuration file has to
- * import on a deployment that ships no embedding model at all. Either way the
- * anchor lands stamped `ANCHOR_EMBEDDING_PENDING`, which the existing lazy
- * repair (`refreshAnchorForEmbedder`) treats as needing a fresh vector the
- * first time the filter is matched.
- */
-export type EmbedAnchor = (
-	sourceText: string,
-) => Promise<{ embedding: number[]; embeddingId: string } | undefined>;
-
 /**
  * Persist one role's folder appointment. Injected rather than composed here:
  * an appointment row means a person decided, and it keeps that meaning only
@@ -86,17 +69,5 @@ export type AppointFolderRole = (
 export interface ConfigImportDeps {
 	repositories: ConfigImportRepositories;
 	appointFolderRole: AppointFolderRole;
-	/**
-	 * Runs the whole apply as one write set, rolling back on any throw.
-	 *
-	 * Optional, and its presence is the fact the report words itself from: a
-	 * backend that supplies this rolls a failed apply back to nothing, and one
-	 * that does not leaves behind whatever landed before the failure. Only the
-	 * caller knows which, so it says so by passing this or omitting it rather
-	 * than by handing over a pass-through that would claim atomicity it has not
-	 * got.
-	 */
-	transaction?: <T>(run: () => Promise<T>) => Promise<T>;
-	embedAnchor?: EmbedAnchor;
 	now?: () => number;
 }