@remit/drizzle-service 0.0.98 → 0.0.100

package/src/search/thread-message-search.ts

@@ -0,0 +1,271 @@
+import {
+	and,
+	asc,
+	count,
+	desc,
+	eq,
+	gt,
+	inArray,
+	lt,
+	or,
+	type SQL,
+	sql,
+} from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { runBatch, type SqliteBatchItem } from "../batch.js";
+import type { Db } from "../db.js";
+import { threadMessageTable } from "../schema/thread-message.js";
+
+// The FTS5 trigram table the search migration set creates
+// (deploy/vps/migrations-sqlite/search). drizzle-kit cannot express a virtual
+// table, so its DDL is that committed migration and this declaration only lets
+// drizzle build statements against it; no drizzle-kit config reads it.
+export const threadMessageSearchTable = sqliteTable("thread_message_fts", {
+	rowid: integer("rowid").notNull(),
+	threadMessageId: text("thread_message_id").notNull(),
+	accountConfigId: text("account_config_id").notNull(),
+	mailboxId: text("mailbox_id").notNull(),
+	sentDate: integer("sent_date").notNull(),
+	listId: text("list_id").notNull(),
+	subject: text("subject").notNull(),
+	sender: text("sender").notNull(),
+	body: text("body").notNull(),
+});
+
+type AnyDb = Db<Record<string, unknown>>;
+
+type SearchDocument = typeof threadMessageSearchTable.$inferInsert;
+
+// D1 refuses a statement with more than 100 bound parameters. A document is
+// nine parameters, so ten documents per insert stay under it.
+const DOCUMENTS_PER_STATEMENT = 10;
+const DOCUMENTS_PER_REBUILD_PAGE = DOCUMENTS_PER_STATEMENT * 30;
+
+// The document's rowid, derived from its thread message id so a write or a
+// removal finds the document without a lookup. 53 bits, the integers a number
+// carries exactly on every driver.
+export const searchRowid = (threadMessageId: string): number => {
+	let h1 = 0xdeadbeef;
+	let h2 = 0x41c6ce57;
+	for (let index = 0; index < threadMessageId.length; index++) {
+		const code = threadMessageId.charCodeAt(index);
+		h1 = Math.imul(h1 ^ code, 2654435761);
+		h2 = Math.imul(h2 ^ code, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
+	h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+	h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
+	h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+	return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+};
+
+const indexedColumns = {
+	threadMessageId: threadMessageTable.threadMessageId,
+	accountConfigId: threadMessageTable.accountConfigId,
+	mailboxId: threadMessageTable.mailboxId,
+	sentDate: threadMessageTable.sentDate,
+	listId: threadMessageTable.listId,
+	subject: threadMessageTable.subject,
+	fromName: threadMessageTable.fromName,
+	fromEmail: threadMessageTable.fromEmail,
+	snippet: threadMessageTable.snippet,
+};
+
+interface IndexedRow {
+	threadMessageId: string;
+	accountConfigId: string;
+	mailboxId: string;
+	sentDate: number;
+	listId: string | null;
+	subject: string | null;
+	fromName: string | null;
+	fromEmail: string | null;
+	snippet: string | null;
+}
+
+const toDocument = (row: IndexedRow): SearchDocument => ({
+	rowid: searchRowid(row.threadMessageId),
+	threadMessageId: row.threadMessageId,
+	accountConfigId: row.accountConfigId,
+	mailboxId: row.mailboxId,
+	sentDate: row.sentDate,
+	listId: row.listId ?? "",
+	subject: row.subject ?? "",
+	sender: `${row.fromName ?? ""} ${row.fromEmail ?? ""}`,
+	body: row.snippet ?? "",
+});
+
+const chunk = <T>(items: readonly T[], size: number): T[][] => {
+	const chunks: T[][] = [];
+	for (let start = 0; start < items.length; start += size) {
+		chunks.push(items.slice(start, start + size));
+	}
+	return chunks;
+};
+
+/** Where a page of candidates resumes: the last one the previous page held. */
+export interface SearchPosition {
+	rank: number;
+	sentDate: number;
+	threadMessageId: string;
+}
+
+export type SearchCandidate = SearchPosition;
+
+export interface CandidateQuery {
+	accountConfigId: string;
+	/** The mailboxes in scope; every mailbox of the config when absent. */
+	mailboxIds?: readonly string[];
+	/** The text condition, over the columns of {@link threadMessageSearchTable}. */
+	where: SQL;
+	/** Ranks first, highest first, when given. */
+	rank?: SQL<number>;
+	order: "asc" | "desc";
+	after: SearchPosition | null;
+	limit: number;
+}
+
+/**
+ * The thread-message search index, kept in its own database.
+ *
+ * It is written after the mail write it follows has committed, and never in
+ * the same batch: a write reads the rows it names back from the mail database
+ * and makes the index match them, so repeating one is harmless and a missed one
+ * is repaired by the next write to that row or by {@link rebuild}.
+ *
+ * A search is answered here — matched, scoped to its mailboxes, ordered and
+ * cut to a page — and the mail database is then asked for that page's rows
+ * only, so no statement carries more ids than a page holds.
+ */
+export class SearchIndex {
+	constructor(
+		private readonly mail: AnyDb,
+		private readonly search: AnyDb,
+	) {}
+
+	/** Make the index match the mail database for these thread messages. */
+	async sync(threadMessageIds: readonly string[]): Promise<void> {
+		const ids = [...new Set(threadMessageIds)];
+		for (const slice of chunk(ids, DOCUMENTS_PER_STATEMENT)) {
+			const rows = await this.mail
+				.select(indexedColumns)
+				.from(threadMessageTable)
+				.where(inArray(threadMessageTable.threadMessageId, slice));
+			const items: SqliteBatchItem[] = [
+				this.search
+					.delete(threadMessageSearchTable)
+					.where(
+						inArray(threadMessageSearchTable.rowid, slice.map(searchRowid)),
+					),
+			];
+			if (rows.length > 0) {
+				items.push(
+					this.search
+						.insert(threadMessageSearchTable)
+						.values(rows.map(toDocument)),
+				);
+			}
+			await runBatch(this.search, items);
+		}
+	}
+
+	async removeAccount(accountConfigId: string): Promise<void> {
+		await this.search
+			.delete(threadMessageSearchTable)
+			.where(eq(threadMessageSearchTable.accountConfigId, accountConfigId));
+	}
+
+	/** One page of matching thread messages, in the query's order. */
+	async candidates(query: CandidateQuery): Promise<SearchCandidate[]> {
+		const table = threadMessageSearchTable;
+		// The rank is computed once, in the inner select, and read by name
+		// after it: written out in the keyset and the ordering it would bind
+		// every term's parameters four times.
+		const matches = this.search
+			.select({
+				threadMessageId: table.threadMessageId,
+				sentDate: table.sentDate,
+				rank: (query.rank ?? sql<number>`0`).as("sender_rank"),
+			})
+			.from(table)
+			.where(
+				and(
+					eq(table.accountConfigId, query.accountConfigId),
+					query.mailboxIds
+						? sql`${table.mailboxId} in (select value from json_each(${JSON.stringify(query.mailboxIds)}))`
+						: undefined,
+					query.where,
+				),
+			)
+			.as("matches");
+		const { after } = query;
+		const dateAfter = after
+			? or(
+					query.order === "desc"
+						? lt(matches.sentDate, after.sentDate)
+						: gt(matches.sentDate, after.sentDate),
+					and(
+						eq(matches.sentDate, after.sentDate),
+						gt(matches.threadMessageId, after.threadMessageId),
+					),
+				)
+			: undefined;
+		const keyset =
+			after && query.rank
+				? or(
+						lt(matches.rank, after.rank),
+						and(eq(matches.rank, after.rank), dateAfter),
+					)
+				: dateAfter;
+		return this.search
+			.select()
+			.from(matches)
+			.where(keyset)
+			.orderBy(
+				...(query.rank ? [desc(matches.rank)] : []),
+				query.order === "desc" ? desc(matches.sentDate) : asc(matches.sentDate),
+				asc(matches.threadMessageId),
+			)
+			.limit(query.limit);
+	}
+
+	/**
+	 * Whether the index has fallen out of step with the mail database: a
+	 * different number of documents than thread messages, as a new or deleted
+	 * search database, or a write that died between the two, leaves it.
+	 */
+	async needsRebuild(): Promise<boolean> {
+		const [[documents], [threads]] = await Promise.all([
+			this.search.select({ n: count() }).from(threadMessageSearchTable),
+			this.mail.select({ n: count() }).from(threadMessageTable),
+		]);
+		return documents?.n !== threads?.n;
+	}
+
+	/** Drop every document and index the whole mail database again. */
+	async rebuild(): Promise<number> {
+		await this.search.delete(threadMessageSearchTable);
+		let indexed = 0;
+		let after = "";
+		for (;;) {
+			const rows = await this.mail
+				.select(indexedColumns)
+				.from(threadMessageTable)
+				.where(gt(threadMessageTable.threadMessageId, after))
+				.orderBy(asc(threadMessageTable.threadMessageId))
+				.limit(DOCUMENTS_PER_REBUILD_PAGE);
+			const last = rows.at(-1);
+			if (!last) return indexed;
+			await runBatch(
+				this.search,
+				chunk(rows, DOCUMENTS_PER_STATEMENT).map((slice) =>
+					this.search
+						.insert(threadMessageSearchTable)
+						.values(slice.map(toDocument)),
+				),
+			);
+			indexed += rows.length;
+			after = last.threadMessageId;
+		}
+	}
+}

package/src/sqlite-client.ts

@@ -1,5 +1,4 @@
 import type { Db } from "./db.js";
-import { serializeSqliteWrites } from "./tx.js";
 
 // The one place a SQLite connection is opened for the app (RFC 036 D3). Every
 // writer container (backend, imap-worker, smtp-worker, account-worker) opens the
@@ -7,10 +6,9 @@ import { serializeSqliteWrites } from "./tx.js";
 // readers, a 5 s busy_timeout so a writer waits out another's short transaction
 // instead of failing, synchronous=NORMAL (durable under WAL), foreign keys on.
 //
-// The handle is wrapped by `serializeSqliteWrites` before it leaves this
-// function, so a repo's insert/update/delete cannot bypass the in-process write
-// serialization (RFC 036 D3). `run`/`transaction`/reads pass through by design —
-// see the wrapper's comment.
+// No write on this handle holds a transaction open across an `await`: a write
+// set runs as one synchronous batch (`batch.ts`), so the shared connection is
+// never inside another caller's transaction when a plain write lands.
 //
 // better-sqlite3 and its drizzle driver are imported dynamically so the whole
 // module stays out of the DynamoDB Lambda bundle (this package is `external`
@@ -40,10 +38,10 @@ export async function createSqliteDatabase<
 	sqlite.pragma("synchronous = NORMAL");
 	sqlite.pragma("foreign_keys = ON");
 
-	const base: Db<TSchema> = drizzle(sqlite, { schema });
+	const db: Db<TSchema> = drizzle(sqlite, { schema });
 
 	return {
-		db: serializeSqliteWrites(base),
+		db,
 		close: async () => {
 			sqlite.close();
 		},

package/src/sqlite-repositories.ts

@@ -0,0 +1,75 @@
+import type { SqliteDatabases } from "./databases.js";
+import { CalendarCollectionRepo } from "./repos/calendar-collection.js";
+import { CalendarEventIndexRepo } from "./repos/calendar-event-index.js";
+import { CalendarFeedTokenRepo } from "./repos/calendar-feed-token.js";
+import { CalendarObjectRepo } from "./repos/calendar-object.js";
+import { DrizzleCalendarStore } from "./repos/calendar-store.js";
+import { CalendarSuggestionRepo } from "./repos/calendar-suggestion.js";
+import { DrizzleEnvelopeRepository } from "./repos/envelope.js";
+import { FilterRepo } from "./repos/filter.js";
+import { AccountRepo } from "./repos/i4-account.js";
+import { AccountConfigRepo } from "./repos/i4-account-config.js";
+import { AccountExportRequestRepo } from "./repos/i4-account-export-request.js";
+import { AccountSettingRepo } from "./repos/i4-account-setting.js";
+import { AddressRepo } from "./repos/i4-address.js";
+import { ConfigImportRepo } from "./repos/i4-config-import.js";
+import { MailboxRepo } from "./repos/i4-mailbox.js";
+import { MailboxLockRepo } from "./repos/i4-mailbox-lock.js";
+import { MailboxSpecialUseRepo } from "./repos/i4-mailbox-special-use.js";
+import { MessageFlagPushRepo } from "./repos/i4-message-flag-push.js";
+import { MessagePlacementMoveRepo } from "./repos/i4-message-placement-move.js";
+import { OrganizeJobRequestRepo } from "./repos/i4-organize-job-request.js";
+import { OutboxAttachmentRepo } from "./repos/i4-outbox-attachment.js";
+import { OutboxMessageRepo } from "./repos/i4-outbox-message.js";
+import { SenderSignerStandingRepo } from "./repos/i4-sender-signer-standing.js";
+import { LabelRepo } from "./repos/label.js";
+import { DrizzleMessageRepository } from "./repos/message.js";
+import { DrizzleMessageFlagRepository } from "./repos/message-flag.js";
+import { MessageLabelRepo } from "./repos/message-label.js";
+import { QuarantineRepo } from "./repos/quarantine.js";
+import { SyncWarningRepo } from "./repos/sync-warning.js";
+import { DrizzleThreadMessageRepository } from "./repos/thread-message.js";
+import { SearchIndex } from "./search/thread-message-search.js";
+
+// Every repo over the database that holds its tables (#1420).
+export const createSqliteRepositories = ({
+	app,
+	mail,
+	search,
+}: SqliteDatabases) => {
+	const searchIndex = new SearchIndex(mail, search);
+	return {
+		accountConfig: new AccountConfigRepo(app, mail),
+		account: new AccountRepo(app, mail),
+		accountSetting: new AccountSettingRepo(app),
+		address: new AddressRepo(mail),
+		mailbox: new MailboxRepo(mail, searchIndex),
+		mailboxSpecialUse: new MailboxSpecialUseRepo(app, mail),
+		mailboxLock: new MailboxLockRepo(mail),
+		message: new DrizzleMessageRepository(mail, searchIndex),
+		messageFlag: new DrizzleMessageFlagRepository(mail),
+		outboxMessage: new OutboxMessageRepo(mail),
+		outboxAttachment: new OutboxAttachmentRepo(mail),
+		threadMessage: new DrizzleThreadMessageRepository(mail, searchIndex),
+		envelope: new DrizzleEnvelopeRepository(mail),
+		accountExportRequest: new AccountExportRequestRepo(app),
+		configImport: new ConfigImportRepo(app),
+		quarantine: new QuarantineRepo(mail),
+		syncWarning: new SyncWarningRepo(mail),
+		organizeJobRequest: new OrganizeJobRequestRepo(mail),
+		placementMove: new MessagePlacementMoveRepo(mail),
+		flagPush: new MessageFlagPushRepo(mail),
+		filter: new FilterRepo(app),
+		label: new LabelRepo(app),
+		messageLabel: new MessageLabelRepo(mail),
+		senderSignerStanding: new SenderSignerStandingRepo(mail),
+		calendarCollection: new CalendarCollectionRepo(app),
+		calendarObject: new CalendarObjectRepo(app),
+		calendarEventIndex: new CalendarEventIndexRepo(app),
+		calendarFeedToken: new CalendarFeedTokenRepo(app),
+		calendarSuggestion: new CalendarSuggestionRepo(mail),
+		calendarStore: new DrizzleCalendarStore(app, mail),
+	};
+};
+
+export type SqliteRepositories = ReturnType<typeof createSqliteRepositories>;

package/src/test-db-sqlite.ts

@@ -1,16 +1,8 @@
-import { readFileSync } from "node:fs";
 import Database from "better-sqlite3";
 import { pushSQLiteSchema } from "drizzle-kit/api";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import type { Db } from "./db.js";
-
-// The exact FTS5 objects the migrator installs (RFC 036 D4), read from the one
-// committed source so a test runs the real search path, not a hand-copied twin.
-const searchIndexDdl = (): string =>
-	readFileSync(
-		new URL("../../../npm-scripts/sqlite-search-index.sql", import.meta.url),
-		"utf8",
-	);
+import { applyMigrationSet } from "./test-shipped-sqlite-schema.js";
 
 // A real better-sqlite3 database (in-memory by default) with the schema pushed
 // from the drizzle table objects — the sqlite `pushSchema` — so a repo runs
@@ -53,11 +45,11 @@ export async function createSqliteTestDb<
 		sqlite.exec(statement);
 	}
 
-	// Install the FTS5 search objects on top of the pushed schema so the
-	// thread-message search predicates run their real trigram path (RFC 036 D4).
-	// Opt-in: only schemas that include the `thread_message` table can carry it.
+	// Install the committed search set beside the pushed schema so the
+	// thread-message search predicates run their real trigram path. The one
+	// handle then plays both the mail and the search database.
 	if (options?.searchIndex) {
-		sqlite.exec(searchIndexDdl());
+		applyMigrationSet(sqlite, "search");
 	}
 
 	return {

package/src/test-shipped-sqlite-schema.ts

@@ -1,7 +1,7 @@
-import { readdirSync, readFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import type Database from "better-sqlite3";
 
-// Read the committed SQLite entity migrations — the DDL a self-host deployment
+// Read the committed SQLite migrations — the DDL a self-host deployment
 // actually runs — so a test can exercise the shipped shape instead of the one
 // `pushSQLiteSchema` derives from the drizzle table objects. The two are
 // generated from the same entities but only the pushed one is regenerated on
@@ -9,67 +9,68 @@ import type Database from "better-sqlite3";
 // (reader#73). Reading the files means a test fails when they drift, and
 // tracks them when they change.
 
-const MIGRATIONS_DIR = new URL(
-	"../../../deploy/vps/migrations-sqlite/entities/",
-	import.meta.url,
-);
+/** The three databases a deployment migrates, one committed set each (#1420). */
+export type MigrationSet = "app" | "mail" | "search";
 
-export const migrationSql = (tag: string): string =>
-	readFileSync(new URL(`${tag}.sql`, MIGRATIONS_DIR), "utf8");
+export const MIGRATION_SETS: readonly MigrationSet[] = [
+	"app",
+	"mail",
+	"search",
+];
 
-export interface MigrationJournalEntry {
+const setDir = (set: MigrationSet): URL =>
+	new URL(`../../../deploy/vps/migrations-sqlite/${set}/`, import.meta.url);
+
+const migrationSql = (set: MigrationSet, tag: string): string =>
+	readFileSync(new URL(`${tag}.sql`, setDir(set)), "utf8");
+
+interface MigrationJournalEntry {
 	idx: number;
 	tag: string;
 }
 
-/** Every committed entity migration, in the order the migrator runs them. */
-export const migrationJournal = (): MigrationJournalEntry[] =>
+/** Every committed migration of a set, in the order the migrator runs them. */
+const migrationJournal = (set: MigrationSet): MigrationJournalEntry[] =>
 	(
 		JSON.parse(
-			readFileSync(new URL("meta/_journal.json", MIGRATIONS_DIR), "utf8"),
+			readFileSync(new URL("meta/_journal.json", setDir(set)), "utf8"),
 		) as { entries: MigrationJournalEntry[] }
-	).entries;
-
-/** The `.sql` files present on disk, whatever the journal says about them. */
-export const migrationTagsOnDisk = (): string[] =>
-	readdirSync(MIGRATIONS_DIR)
-		.filter((name) => name.endsWith(".sql"))
-		.map((name) => name.slice(0, -".sql".length))
-		.sort();
-
-export interface MigrationSnapshot {
-	id: string;
-	prevId: string;
-}
+	).entries.sort((left, right) => left.idx - right.idx);
 
-export const migrationSnapshot = (idx: number): MigrationSnapshot =>
-	JSON.parse(
-		readFileSync(
-			new URL(
-				`meta/${String(idx).padStart(4, "0")}_snapshot.json`,
-				MIGRATIONS_DIR,
-			),
-			"utf8",
-		),
-	) as MigrationSnapshot;
-
-/** The `CREATE TABLE` block for one table, as that migration declares it. */
-export const shippedTableDdl = (tag: string, table: string): string => {
-	const match = migrationSql(tag).match(
+/** The `CREATE TABLE` block for one mail table, as the mail baseline declares it. */
+export const shippedTableDdl = (table: string): string => {
+	const [baseline] = migrationJournal("mail");
+	const match = migrationSql("mail", baseline.tag).match(
 		new RegExp(`CREATE TABLE \`${table}\` \\([\\s\\S]*?\\n\\);`),
 	);
 	if (!match) {
-		throw new Error(`${table} DDL not found in migration ${tag}`);
+		throw new Error(`${table} DDL not found in migration ${baseline.tag}`);
 	}
 	return match[0];
 };
 
-/** Run every statement of a committed migration against an open database. */
-export const applyMigration = (
+/** The one statement of the mail baseline that creates a named index. */
+export const shippedIndexDdl = (index: string): string => {
+	const [baseline] = migrationJournal("mail");
+	const statement = migrationSql("mail", baseline.tag)
+		.split("--> statement-breakpoint")
+		.find((candidate) => candidate.includes(`INDEX \`${index}\``));
+	if (!statement) {
+		throw new Error(`${index} not found in migration ${baseline.tag}`);
+	}
+	return statement;
+};
+
+/** Run every committed migration of a set against an open database. */
+export const applyMigrationSet = (
 	sqlite: Database.Database,
-	tag: string,
+	set: MigrationSet,
 ): void => {
-	for (const statement of migrationSql(tag).split("--> statement-breakpoint")) {
-		sqlite.exec(statement);
+	for (const entry of migrationJournal(set)) {
+		for (const statement of migrationSql(set, entry.tag).split(
+			"--> statement-breakpoint",
+		)) {
+			sqlite.exec(statement);
+		}
 	}
 };

package/src/test-sqlite.ts

@@ -1,23 +1,25 @@
+import { join } from "node:path";
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
+import { SQLITE_DATABASE_ENV, type SqliteDatabasePaths } from "./databases.js";
 import type { Db } from "./db.js";
 import {
-	applyMigration,
-	migrationJournal,
+	applyMigrationSet,
+	MIGRATION_SETS,
 } from "./test-shipped-sqlite-schema.js";
 
 /**
- * The store a test runs against: the committed SQLite entity migrations, in the
- * order the migrator runs them, over the same engine a self-host deployment
- * boots. Applying the shipped DDL rather than pushing the drizzle table objects
- * is the point — a test then fails when the two drift (reader#73).
+ * The store a test runs against: the committed SQLite migrations, in the order
+ * the migrator runs them, over the same engine a self-host deployment boots.
+ * Applying the shipped DDL rather than pushing the drizzle table objects is the
+ * point — a test then fails when the two drift (reader#73).
+ *
+ * All three sets land in the one database, which a test then hands to every
+ * repo whatever database the repo runs on in a deployment. Their tables do not
+ * overlap, so nothing collides.
  */
 export const applyShippedMigrations = (sqlite: Database.Database): void => {
-	for (const entry of [...migrationJournal()].sort(
-		(left, right) => left.idx - right.idx,
-	)) {
-		applyMigration(sqlite, entry.tag);
-	}
+	for (const set of MIGRATION_SETS) applyMigrationSet(sqlite, set);
 };
 
 /**
@@ -37,3 +39,25 @@ export const createShippedSqliteDb = (): {
 		close: () => sqlite.close(),
 	};
 };
+
+/**
+ * The three database files a deployment runs on, each migrated with its own
+ * set, under `directory` — and the environment pointed at them, so a
+ * composition root a test builds opens them exactly as a deployment does.
+ */
+export const createShippedSqliteFiles = (
+	directory: string,
+): SqliteDatabasePaths => {
+	const paths: SqliteDatabasePaths = {
+		app: join(directory, "app.db"),
+		mail: join(directory, "mail.db"),
+		search: join(directory, "search.db"),
+	};
+	for (const set of MIGRATION_SETS) {
+		const sqlite = new Database(paths[set]);
+		applyMigrationSet(sqlite, set);
+		sqlite.close();
+		process.env[SQLITE_DATABASE_ENV[set]] = paths[set];
+	}
+	return paths;
+};