@remit/config-transfer 0.0.11 → 0.0.13

package/package.json

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

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;
@@ -130,11 +128,10 @@ export const makeFilter = (
 	scope: "Standing",
 	state: "Active",
 	disabledReason: "None",
-	hasAnchor: false,
 	ruleChangedAt: NOW,
 	actionChangedAt: NOW,
 	matchOperator: "And",
-	literalClauses: [],
+	literalClauses: [{ field: "Subject", value: "release notes" }],
 	actionLabelId: "None",
 	actionMailboxId: "None",
 	createdAt: NOW,
@@ -142,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">,
@@ -287,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;
 }

package/src/import.test.ts

@@ -6,7 +6,6 @@ import type {
 	AccountSettingItem,
 	AddressItem,
 	ConfigImportItem,
-	FilterAnchorItem,
 	FilterItem,
 	LabelItem,
 	MailboxItem,
@@ -30,7 +29,6 @@ import {
 	makeAccount,
 	makeAccountConfig,
 	makeAddress,
-	makeAnchor,
 	makeFilter,
 	makeJunkOnlyFlaggedAddress,
 	makeLabel,
@@ -41,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 = {
@@ -52,8 +50,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";
@@ -74,7 +70,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. */
@@ -92,7 +87,6 @@ const emptyStore = (): Store => ({
 	mailboxes: [],
 	labels: [],
 	filters: [],
-	anchors: [],
 	addresses: [],
 	imports: [],
 });
@@ -108,7 +102,6 @@ const storeFromFixture = (fixture: ConfigFixture): Store => ({
 	mailboxes: [...fixture.mailboxes],
 	labels: [...fixture.labels],
 	filters: [...fixture.filters],
-	anchors: [...fixture.anchors],
 	addresses: [...fixture.addresses],
 	imports: [],
 });
@@ -244,19 +237,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).
@@ -392,50 +372,15 @@ const settle = (
 	return next;
 };
 
-/**
- * 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 =
-	(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;
-		});
-	};
-
-const depsOf = (
-	store: Store,
-	accountConfigId: string,
-	embed = true,
-): ConfigImportDeps => ({
+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.
 // ---------------------------------------------------------------------------
 
@@ -543,14 +488,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",
@@ -597,7 +540,6 @@ const apply = (
 ) =>
 	importConfig(depsOf(store, TARGET_CONFIG_ID), {
 		accountConfigId: TARGET_CONFIG_ID,
-		userId: TARGET_USER_ID,
 		document,
 		mode: "apply",
 		onExisting,
@@ -703,7 +645,6 @@ test("validate writes nothing and still says what an apply would do", async () =
 
 	const outcome = await importConfig(depsOf(store, TARGET_CONFIG_ID), {
 		accountConfigId: TARGET_CONFIG_ID,
-		userId: TARGET_USER_ID,
 		document,
 		mode: "validate",
 		onExisting: "abort",
@@ -731,7 +672,6 @@ test("a configuration that already holds something refuses the default import",
 
 	const outcome = await importConfig(depsOf(store, ACCOUNT_CONFIG_ID), {
 		accountConfigId: ACCOUNT_CONFIG_ID,
-		userId: TARGET_USER_ID,
 		document,
 		mode: "apply",
 		onExisting: "abort",
@@ -758,7 +698,6 @@ test("a junk-only sender the user decided about still holds the configuration",
 
 	const outcome = await importConfig(depsOf(store, ACCOUNT_CONFIG_ID), {
 		accountConfigId: ACCOUNT_CONFIG_ID,
-		userId: TARGET_USER_ID,
 		document,
 		mode: "apply",
 		onExisting: "abort",
@@ -974,7 +913,6 @@ test("the dry run names the filters an apply would leave off", async () => {
 
 	const outcome = await importConfig(depsOf(store, TARGET_CONFIG_ID), {
 		accountConfigId: TARGET_CONFIG_ID,
-		userId: TARGET_USER_ID,
 		document,
 		mode: "validate",
 		onExisting: "abort",
@@ -1570,67 +1508,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();
@@ -1638,7 +1515,6 @@ test("the dry run names the same folders and credentials the apply does", async
 	const planned = reportOf(
 		await importConfig(depsOf(planStore, TARGET_CONFIG_ID), {
 			accountConfigId: TARGET_CONFIG_ID,
-			userId: TARGET_USER_ID,
 			document,
 			mode: "validate",
 			onExisting: "abort",
@@ -1659,7 +1535,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";
@@ -1667,40 +1543,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(
@@ -1712,6 +1556,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();
@@ -1721,7 +1588,7 @@ test("the configuration row is created when the database holds none, and named f
 	assert.equal(store.accountConfigs.get(TARGET_CONFIG_ID)?.name, "Matthijs");
 	assert.equal(
 		store.accountConfigs.get(TARGET_CONFIG_ID)?.userId,
-		TARGET_USER_ID,
+		TARGET_CONFIG_ID,
 	);
 	assert.equal(
 		store.settings.get("DefaultComposerFormat")?.value.value,

package/src/import.ts

@@ -14,11 +14,11 @@ import {
 	type FilterItem,
 	type LabelItem,
 } from "@remit/data-ports";
+import { ensureAccountConfig } from "@remit/data-ports/account-config";
 import {
 	type AccountSettingNameValue,
 	composeSettingName,
 } from "@remit/data-ports/account-settings";
-import { NotFoundError } from "@remit/data-ports/errors";
 import type { CanonicalMailboxRoleValue } from "@remit/data-ports/folder-role";
 import { deriveAddressId } from "@remit/data-ports/id";
 import {
@@ -39,24 +39,11 @@ import {
 	ConfigImportVerdict,
 } from "./report.js";
 
-/**
- * The `<modelId>@<dimensions>` stamp an anchor carries when this deployment
- * could not embed its source text at import time. It matches no real embedder,
- * which is what makes the existing lazy repair (`refreshAnchorForEmbedder`)
- * treat the anchor as needing a fresh vector the first time it is matched —
- * the same route a model migration takes. Deliberately the same literal as
- * `UNKNOWN_CHUNK_EMBEDDING_ID` in `@remit/search-service`, which config
- * transfer cannot import without dragging the vector stack into the CLI.
- */
-export const ANCHOR_EMBEDDING_PENDING = "unknown";
-
 /** The named sentinel a Filter carries for "no action of this kind". */
 const NO_ACTION = "None";
 
 export interface ImportConfigInput {
 	accountConfigId: string;
-	/** Owner of a configuration this import may have to create the row for. */
-	userId: string;
 	document: unknown;
 	mode: "validate" | "apply";
 	onExisting: "abort" | "merge";
@@ -270,9 +257,9 @@ const landingState = (
 
 /**
  * What the apply has decided so far. Owned by `importConfig` rather than by
- * `applyDocument` so a write that fails part-way still has it: on a backend
- * without a transaction those items are what actually landed, and a report that
- * threw them away would name a stopping point without naming the state.
+ * `applyDocument` so a write that fails part-way still has it: those items are
+ * what actually landed, and a report that threw them away would name a stopping
+ * point without naming the state.
  */
 interface ApplyProgress {
 	items: ConfigImportItemReport[];
@@ -288,56 +275,6 @@ const emptyProgress = (): ApplyProgress => ({
 	unresolvedRefs: [],
 });
 
-interface AnchorVector {
-	embedding: number[];
-	embeddingId: string;
-}
-
-/**
- * Every anchor's vector, computed before the transaction opens.
- *
- * Two reasons it happens here and not at the point of write. An embedder is a
- * network round trip and the sqlite write queue is process-wide, so embedding
- * inside the transaction holds that queue against every other writer for the
- * length of the call. And a failed embed is not a failed import: it degrades
- * exactly the way a deployment that ships no embedder does, landing the anchor
- * stamped `ANCHOR_EMBEDDING_PENDING` for the lazy repair to rebuild the first
- * time the filter runs. A 503 from the embedder must not cost a person their
- * configuration.
- */
-const embedAnchors = async (
-	deps: ConfigImportDeps,
-	document: ReaderConfigDocument,
-	warnings: ConfigImportProblem[],
-): Promise<Map<string, AnchorVector>> => {
-	const vectors = new Map<string, AnchorVector>();
-	const { embedAnchor } = deps;
-
-	for (const filter of document.filters) {
-		const { anchor } = filter;
-		if (anchor === null) continue;
-
-		const embedded = embedAnchor
-			? await embedAnchor(anchor.sourceText).catch(() => undefined)
-			: undefined;
-
-		if (embedded) {
-			vectors.set(normalize(filter.name), embedded);
-			continue;
-		}
-
-		warnings.push(
-			problem(
-				"anchor_not_embedded",
-				`The example behind filter "${filter.name}" is carried as text; its vector is rebuilt the first time the filter runs.`,
-				{ filter: filter.name },
-			),
-		);
-	}
-
-	return vectors;
-};
-
 /**
  * The id this instance will hold each account in the file under: the one it
  * already has for that id or email, or the file's own, which `create` preserves
@@ -378,8 +315,7 @@ const foldersFor = (
 
 /**
  * A write that failed after validation. It carries the item it stopped on so
- * the report can name it: the import is atomic, so nothing landed, and where it
- * stopped is the only fact worth recovering from.
+ * the report can name it beside what landed before it.
  */
 class ImportWriteError extends Error {
 	constructor(
@@ -399,7 +335,6 @@ const applyDocument = async (
 	input: ImportConfigInput,
 	document: ReaderConfigDocument,
 	existing: ExistingConfig,
-	anchorVectors: ReadonlyMap<string, AnchorVector>,
 	progress: ApplyProgress,
 ): Promise<string> => {
 	const { repositories } = deps;
@@ -430,7 +365,7 @@ const applyDocument = async (
 	// First: everything below hangs off it, and on a fresh instance there is no
 	// row for an account to reference until this has run.
 	await write(ConfigImportSection.Settings, "accountConfig", () =>
-		ensureAccountConfig(deps, input, document),
+		nameAccountConfig(deps, input, document),
 	);
 
 	// ---- accounts -------------------------------------------------------
@@ -485,8 +420,7 @@ const applyDocument = async (
 			account.email,
 			() =>
 				repositories.account.create({
-					// Verbatim: a resynced message id hashes from it, so preserving it is
-					// what keeps every filter anchor's provenance valid across the drop.
+					// Verbatim: a resynced message id hashes from it.
 					accountId: account.accountId,
 					accountConfigId,
 					...endpoints,
@@ -545,7 +479,6 @@ const applyDocument = async (
 	const existingFilterByName = new Map(
 		existing.filters.map((filter) => [normalize(filter.name), filter] as const),
 	);
-	const filterIdByName = new Map<string, string>();
 
 	const resolveFilterFolder = (
 		filter: ConfigFilter,
@@ -574,7 +507,6 @@ const applyDocument = async (
 					? NO_ACTION
 					: (labelIdByName.get(normalize(filter.actionLabelName)) ?? NO_ACTION),
 			actionMailboxId: folder.actionMailboxId,
-			hasAnchor: filter.anchor !== null,
 			...(folder.pending
 				? {
 						state: FilterState.Disabled,
@@ -603,7 +535,6 @@ const applyDocument = async (
 					)
 				).filterId;
 
-		filterIdByName.set(key, filterId);
 		items.push({
 			section: ConfigImportSection.Filters,
 			key: filter.name,
@@ -636,34 +567,6 @@ const applyDocument = async (
 		}
 	}
 
-	// ---- anchors --------------------------------------------------------
-	// Vectors were computed before the transaction opened; a missing one is an
-	// anchor carried as text, already warned about there.
-	for (const filter of document.filters) {
-		const { anchor } = filter;
-		if (anchor === null) continue;
-		const key = normalize(filter.name);
-		const filterId = filterIdByName.get(key);
-		if (filterId === undefined) {
-			throw new Error(
-				`Filter "${filter.name}" carries an anchor but the filter loop minted no id for it. The two loops read the same documents.filters, so this cannot happen without one of them changing.`,
-			);
-		}
-
-		const embedded = anchorVectors.get(key);
-
-		await write(ConfigImportSection.Filters, filter.name, () =>
-			repositories.filterAnchor.put({
-				accountConfigId,
-				filterId,
-				anchorEmbedding: embedded?.embedding ?? [],
-				anchorEmbeddingId: embedded?.embeddingId ?? ANCHOR_EMBEDDING_PENDING,
-				anchorSourceText: anchor.sourceText,
-				anchorMessageId: anchor.sourceMessageId,
-			}),
-		);
-	}
-
 	// ---- address flags --------------------------------------------------
 	for (const entry of document.addressFlags) {
 		await write(ConfigImportSection.AddressFlags, entry.normalizedEmail, () =>
@@ -782,32 +685,17 @@ const writeAddressFlags = async (
 /**
  * The configuration row itself. A fresh instance holds none — `GET /config`
  * synthesizes an empty answer rather than writing one — so an import into a
- * dropped database has to materialize it before anything can hang off it.
+ * dropped database has to materialize it, the same way every other first write
+ * does, before anything can hang off it.
  */
-const ensureAccountConfig = async (
+const nameAccountConfig = async (
 	deps: ConfigImportDeps,
 	input: ImportConfigInput,
 	document: ReaderConfigDocument,
 ): Promise<void> => {
 	const { accountConfig } = deps.repositories;
-	// Absence is the expected answer on a fresh instance and the only one that
-	// means "create it"; anything else is a store fault and belongs to the caller.
-	const held = await accountConfig
-		.get(input.accountConfigId)
-		.catch((error: unknown) => {
-			if (error instanceof NotFoundError) return undefined;
-			throw error;
-		});
+	const held = await ensureAccountConfig(accountConfig, input.accountConfigId);
 	const name = document.accountConfig.name;
-
-	if (!held) {
-		await accountConfig.create({
-			accountConfigId: input.accountConfigId,
-			userId: input.userId,
-			name,
-		});
-		return;
-	}
 	if (name !== "" && name !== held.name) {
 		await accountConfig.update(input.accountConfigId, { name });
 	}
@@ -939,8 +827,8 @@ class SettingWriter {
  *
  * The order is fixed: parse and migrate, check every reference and every
  * natural key against what this configuration already holds, and only then
- * write — inside one transaction, accounts before labels before filters before
- * their anchors before addresses before settings, because each of those reads
+ * write — accounts before labels before filters before
+ * addresses before settings, because each of those reads
  * an id the one before it minted.
  *
  * A document this reader will not import is the operation's expected outcome,
@@ -1004,19 +892,16 @@ export const importConfig = async (
 		};
 	}
 
-	// Before the transaction: an embed is a network round trip, and the write
-	// queue it would otherwise hold is process-wide.
-	const embedWarnings: ConfigImportProblem[] = [];
-	const anchorVectors = await embedAnchors(deps, document, embedWarnings);
-
-	const { transaction } = deps;
-	const atomic = transaction !== undefined;
 	const progress = emptyProgress();
-	const apply = (): Promise<string> =>
-		applyDocument(deps, input, document, existing, anchorVectors, progress);
 
 	try {
-		const importId = await (transaction ? transaction(apply) : apply());
+		const importId = await applyDocument(
+			deps,
+			input,
+			document,
+			existing,
+			progress,
+		);
 		return {
 			outcome: "report",
 			report: {
@@ -1026,16 +911,17 @@ export const importConfig = async (
 				applied: true,
 				items: progress.items,
 				errors: [],
-				warnings: [...embedWarnings, ...progress.warnings],
+				warnings: progress.warnings,
 				accountsNeedingCredentials: progress.accountsNeedingCredentials,
 			},
 		};
 	} catch (error) {
 		if (!(error instanceof ImportWriteError)) throw error;
 		// What the report owes the reader is where it stopped and what is now in
-		// the store. Under a transaction the answer to the second is "nothing";
-		// without one it is everything recorded up to the failure.
-		const landed = atomic ? emptyProgress() : progress;
+		// the store: everything recorded up to the failure. Every write is keyed on
+		// a natural key, so importing the same file again with merge folds the
+		// rest in over what landed.
+		const landed = progress;
 		return {
 			outcome: "report",
 			report: {
@@ -1054,15 +940,11 @@ export const importConfig = async (
 				errors: [
 					problem(
 						"import_write_failed",
-						`${error.message} ${
-							atomic
-								? "Nothing was written; the import stopped here."
-								: "The items above it were written and remain; the import stopped here."
-						}`,
+						`${error.message} The items above it were written and remain; import the same file again with merge to finish.`,
 						{ section: error.section, key: error.key },
 					),
 				],
-				warnings: [...embedWarnings, ...landed.warnings],
+				warnings: landed.warnings,
 				accountsNeedingCredentials: landed.accountsNeedingCredentials,
 			},
 		};

package/src/index.ts

@@ -13,7 +13,6 @@ export {
 	readConfigForExport,
 } from "./export.js";
 export {
-	ANCHOR_EMBEDDING_PENDING,
 	type ImportConfigInput,
 	importConfig,
 } from "./import.js";
@@ -21,7 +20,6 @@ export type {
 	AppointFolderRole,
 	ConfigImportDeps,
 	ConfigImportRepositories,
-	EmbedAnchor,
 } from "./import-repositories.js";
 export {
 	type ConfigImportConflict,

package/src/repositories.ts

@@ -3,7 +3,6 @@ import type {
 	IAccountRepository,
 	IAccountSettingRepository,
 	IAddressRepository,
-	IFilterAnchorRepository,
 	IFilterRepository,
 	ILabelRepository,
 	IMailboxRepository,
@@ -24,7 +23,6 @@ export interface ConfigExportRepositories {
 	mailbox: Pick<IMailboxRepository, "listAllByAccount">;
 	label: Pick<ILabelRepository, "listByAccountConfig">;
 	filter: Pick<IFilterRepository, "listByAccountConfig">;
-	filterAnchor: Pick<IFilterAnchorRepository, "listByAccountConfig">;
 	/**
 	 * Not the suggest listing: that one hides an address the machine marked
 	 * `junkOnly` unless the account has corresponded with it, which is right for