@webappwiz/arbor 0.0.28 → 0.0.30

package/dev.ts

@@ -0,0 +1,386 @@
+import { AsyncDisposer, type AsyncResource } from "webappwiz/disposable";
+import type { Logger } from "webappwiz/log";
+import {
+	type Fs,
+	MAX_PORT,
+	OpenPortProvider,
+	type PortProvider,
+	type Ps,
+} from "webappwiz/system";
+import type { Attachment } from "./attachments";
+import type { Assets } from "./dev/assets";
+import { Exit, fail, type Reason } from "./exit";
+import type { Journal } from "./journal";
+import { fingerprint, snapshot } from "./snapshot";
+import type { Todos } from "./todo";
+import type { WorktreeService } from "./worktree-service";
+
+/** Preferred, not required: `dev` moves up from here when it is taken. */
+export const DEFAULT_PORT = 4269;
+
+/** How far above the port asked for `dev` will look before giving up. */
+export const PORT_SPAN = 20;
+
+/** How often the repo is re-read to decide whether open pages should refetch. */
+const POLL_MS = 2_000;
+
+/** The one address the server binds: this machine, and nothing else. */
+const LOOPBACK = "127.0.0.1";
+
+/** Names this machine answers to, which a page opened on it always may use. */
+const LOCAL_HOSTS = ["localhost", "127.0.0.1", "[::1]"];
+
+/** A phone photo fits; a stray video does not. */
+const MAX_BODY_BYTES = 25 * 1024 * 1024;
+
+/** The images a todo may hold, by extension, and how each is served. */
+const IMAGE_TYPES: Record<string, string> = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+};
+
+/** How a refusal from the core reads over HTTP. */
+const STATUS: Partial<Record<Reason, number>> = {
+	usage: 400,
+	not_found: 404,
+	lease_held: 409,
+	exists: 409,
+};
+
+/** What `dev` lets a caller choose. */
+export interface DevOptions {
+	/** Where to listen; the port `--port` asked for, and the span above it. */
+	ports?: PortProvider;
+	/**
+	 * Host names besides this machine's own that the page may be reached by,
+	 * like the hostname of a tunnel. Anything else is refused, which is what
+	 * stops another site from reading the repo through a browser pointed at
+	 * localhost. Who may use those names is the tunnel's business, not arbor's.
+	 */
+	hosts?: string[];
+}
+
+/** A running server, and the one thing a caller ever wants to do with it. */
+export interface DevServer extends AsyncResource {
+	port: number;
+}
+
+/**
+ * Serves what `todo list`, `list` and `show` print as one page that refetches
+ * when the repo changes, where a person adds, edits, reorders and removes
+ * todos. Anything that moves a task (merge, remove, claim) stays in the CLI,
+ * so a page that should not have been reachable can at worst change a todo.
+ */
+export async function dev(
+	{
+		service,
+		fs,
+		ps,
+		journal,
+		todos,
+		log,
+		assets,
+	}: {
+		service: WorktreeService;
+		fs: Fs;
+		ps: Ps;
+		journal: Journal;
+		todos: Todos;
+		log: Logger;
+		assets: Assets;
+	},
+	{ ports = devPorts(DEFAULT_PORT), hosts = [] }: DevOptions = {},
+): Promise<DevServer> {
+	const home = ps.env("HOME");
+	const read = () => snapshot({ service, todos, fs, home });
+	const allowed = new Set([...LOCAL_HOSTS, ...hosts]);
+	// The page itself is a React app under `dev/`, built before publishing and
+	// carried in the bundle, so nothing here builds markup and nothing reads it
+	// off disk.
+	const open = new Set<ReadableStreamDefaultController<Uint8Array>>();
+	const encoder = new TextEncoder();
+	let last = fingerprint(await read());
+
+	// ponytail: polls, because arbor's state is spread across records, git refs
+	// and ARBOR.md, and one watcher would not cover all three. Watch `.git/arbor`
+	// and the worktree roots if two seconds ever feels slow.
+	const tick = async (): Promise<void> => {
+		const print = fingerprint(await read());
+		if (print === last) {
+			return;
+		}
+		last = print;
+		for (const stream of open) {
+			stream.enqueue(encoder.encode("data: changed\n\n"));
+		}
+	};
+	const poll = setInterval(() => {
+		tick().catch((error: unknown) => log.error(String(error)));
+	}, POLL_MS);
+
+	const events = (): Response => {
+		let self: ReadableStreamDefaultController<Uint8Array> | null = null;
+		return new Response(
+			new ReadableStream<Uint8Array>({
+				start: (stream) => {
+					self = stream;
+					open.add(stream);
+					// A comment, ignored by EventSource. Without a first chunk the
+					// response headers never reach the client and the page hangs
+					// waiting to connect.
+					stream.enqueue(encoder.encode(": connected\n\n"));
+				},
+				cancel: () => {
+					if (self) {
+						open.delete(self);
+					}
+				},
+			}),
+			{
+				headers: {
+					"content-type": "text/event-stream",
+					"cache-control": "no-cache",
+				},
+			},
+		);
+	};
+
+	const asset = (body: string, type: string): Response =>
+		new Response(body, { headers: { "content-type": type } });
+
+	// Every route that reads or writes the repo goes through here. The Host
+	// check is what DNS rebinding runs into; the Origin check is what a form on
+	// another site posting to this one runs into.
+	const guarded =
+		(handle: (request: Request) => Promise<Response>) =>
+		async (request: Request): Promise<Response> => {
+			const host = request.headers.get("host") ?? "";
+			if (!allowed.has(hostname(host))) {
+				return refuse(
+					403,
+					"forbidden",
+					`host '${host}' is not allowed: pass it to --allow-hosts`,
+				);
+			}
+			const origin = request.headers.get("origin");
+			if (
+				request.method !== "GET" &&
+				(origin === null || new URL(origin).host !== host)
+			) {
+				return refuse(403, "forbidden", "cross-origin writes are refused");
+			}
+			try {
+				return await handle(request);
+			} catch (error) {
+				if (error instanceof Exit) {
+					return refuse(
+						STATUS[error.reason] ?? 400,
+						error.reason,
+						error.message,
+					);
+				}
+				log.error(String(error));
+				return refuse(500, "error", String(error));
+			}
+		};
+
+	// Only a file a todo holds, so the page, and whoever a tunnel lets reach
+	// it, can read nothing on this machine that was not put there on purpose.
+	const file = async (request: Request): Promise<Response> => {
+		const params = new URL(request.url).searchParams;
+		const path = params.get("path") ?? "";
+		const type = IMAGE_TYPES[path.split(".").at(-1)?.toLowerCase() ?? ""];
+		const bytes = todos.owns(path)
+			? await fs.readBytes(path).catch(() => null)
+			: null;
+		if (bytes === null) {
+			return refuse(404, "not_found", `nothing here shows ${path}`);
+		}
+		return new Response(new Blob([bytes as Uint8Array<ArrayBuffer>]), {
+			headers: {
+				"content-type": type ?? "application/octet-stream",
+				// Anything not an image downloads rather than rendering here.
+				...(type === undefined ? { "content-disposition": "attachment" } : {}),
+				// An svg opened on its own could otherwise run a script.
+				"content-security-policy":
+					"default-src 'none'; style-src 'unsafe-inline'",
+				"x-content-type-options": "nosniff",
+			},
+		});
+	};
+
+	// Names only, and only what git would show anyone with the repo: enough to
+	// point an agent at a file with `@`, and nothing inside one.
+	const paths = async (request: Request): Promise<Response> => {
+		const task = new URL(request.url).searchParams.get("task") ?? "";
+		const worktree = task === "" ? null : await service.find(task);
+		if (worktree !== null && !worktree.exists) {
+			fail("not_found", `no worktree for '${task}'`, { task });
+		}
+		return Response.json(
+			await service.git.paths(worktree?.path ?? service.git.root),
+		);
+	};
+
+	const addTodo = async (request: Request): Promise<Response> => {
+		const form = await request.formData();
+		const todo = await journal.record("todo add", null, async () =>
+			todos.add(String(form.get("subject") ?? ""), null, {
+				text: String(form.get("text") ?? ""),
+				files: await uploads(form),
+				position: positionIn(form),
+			}),
+		);
+		await tick();
+		return Response.json(todo.state);
+	};
+
+	/** The tags a todo write sends, comma separated. */
+	const tagsIn = (form: FormData): string[] =>
+		String(form.get("tags") ?? "")
+			.split(",")
+			.map((tag) => tag.trim())
+			.filter(Boolean);
+
+	/** Where a todo write asks to put it; absent leaves it to the write. */
+	const positionIn = (form: FormData): number | undefined =>
+		form.has("position") ? Number(form.get("position")) : undefined;
+
+	/** The todo a `/api/todos/<id>` path names, or `/api/todos/<id>/position`. */
+	const todoAt = async (request: Request) => {
+		const raw = new URL(request.url).pathname.split("/")[3] ?? "";
+		const id = Number(raw);
+		if (!Number.isInteger(id) || id <= 0) {
+			fail("usage", `'${raw}' is not a todo id`, { todo: raw });
+		}
+		return todos.find(id);
+	};
+
+	const updateTodo = async (request: Request): Promise<Response> => {
+		const form = await request.formData();
+		const found = await todoAt(request);
+		const todo = await journal.record("todo update", null, async () =>
+			found.update({
+				subject: form.has("subject") ? String(form.get("subject")) : undefined,
+				text: form.has("text") ? String(form.get("text")) : undefined,
+				position: positionIn(form),
+				files: await uploads(form),
+				keep: form.getAll("keep").map(String),
+				tags: form.has("tags") ? tagsIn(form) : undefined,
+			}),
+		);
+		await tick();
+		return Response.json(todo.state);
+	};
+
+	// Its own route, carrying nothing but the place, so a drag can never touch
+	// a todo's words or files.
+	const moveTodo = async (request: Request): Promise<Response> => {
+		const found = await todoAt(request);
+		const { position } = (await request.json()) as { position?: unknown };
+		const todo = await journal.record("todo update", null, () =>
+			found.update({ position: Number(position) }),
+		);
+		await tick();
+		return Response.json(todo.state);
+	};
+
+	const removeTodo = async (request: Request): Promise<Response> => {
+		const found = await todoAt(request);
+		await journal.record("todo remove", null, () => found.remove());
+		await tick();
+		return Response.json(found.state);
+	};
+
+	const requested = await ports.get();
+	const server = Bun.serve({
+		port: requested,
+		// This machine only. Reaching it from anywhere else is a tunnel's job,
+		// which connects from here too.
+		hostname: LOOPBACK,
+		maxRequestBodySize: MAX_BODY_BYTES,
+		// Zero never closes an idle connection, which is what the SSE stream needs:
+		// it is idle by design between the things it has to say.
+		idleTimeout: 0,
+		// The static three are handed over without entering JS; the other two have
+		// to be asked for, since they answer with the state of the repo right now.
+		routes: {
+			"/": asset(assets.shell, "text/html; charset=utf-8"),
+			"/main.js": asset(assets.script, "text/javascript; charset=utf-8"),
+			"/styles.css": asset(assets.styles, "text/css; charset=utf-8"),
+			"/api/snapshot": guarded(async () => Response.json(await read())),
+			"/api/file": guarded(file),
+			"/api/paths": guarded(paths),
+			"/api/todos": { POST: guarded(addTodo) },
+			"/api/todos/:id": {
+				PATCH: guarded(updateTodo),
+				DELETE: guarded(removeTodo),
+			},
+			"/api/todos/:id/position": { PUT: guarded(moveTodo) },
+			"/events": guarded(async () => events()),
+		},
+		fetch: () => new Response("not found", { status: 404 }),
+	});
+	// Read back, because `ports` may hand over 0 to mean any port at all, and
+	// read now, because `server.port` is 0 once the server is stopped and this is
+	// handed to a caller that stops it. Undefined only for a unix socket, which
+	// this never asks for.
+	const port = server.port ?? requested;
+
+	log.info(`arbor dev on http://localhost:${port}`);
+	const disposer = new AsyncDisposer();
+	// true drains open connections rather than cutting them mid-response
+	disposer.defer(() => server.stop(true));
+	disposer.defer(async () => clearInterval(poll));
+	return {
+		port,
+		disposeAsync: disposer.disposeAsync,
+	};
+}
+
+/**
+ * Where `dev` will listen, given the port asked for. A flag is outside input,
+ * so a port that cannot exist is a refusal with an exit code rather than the
+ * assertion `OpenPortProvider` would raise for a bug in here.
+ */
+export function devPorts(from: number): PortProvider {
+	if (!Number.isInteger(from) || from < 0 || from > MAX_PORT) {
+		fail(
+			"usage",
+			`invalid port '${from}': use a whole number 0 to ${MAX_PORT}`,
+			{
+				port: from,
+			},
+		);
+	}
+	return OpenPortProvider.span({ from, span: PORT_SPAN, host: LOOPBACK });
+}
+
+/** The files a form carries under `file`, as bytes. */
+async function uploads(form: FormData): Promise<Attachment[]> {
+	const files: Attachment[] = [];
+	for (const file of form.getAll("file")) {
+		if (file instanceof File) {
+			files.push({
+				name: file.name || "pasted",
+				bytes: new Uint8Array(await file.arrayBuffer()),
+			});
+		}
+	}
+	return files;
+}
+
+/** The host a Host header names, without its port. */
+function hostname(host: string): string {
+	return host.startsWith("[")
+		? host.slice(0, host.indexOf("]") + 1)
+		: (host.split(":")[0] ?? "");
+}
+
+function refuse(status: number, reason: string, message: string): Response {
+	return Response.json({ reason, message }, { status });
+}

package/e2e.test.ts

@@ -0,0 +1,256 @@
+import { describe, expect, it, setDefaultTimeout } from "bun:test";
+import { join } from "node:path";
+import { ensure } from "webappwiz/assert";
+import { color } from "webappwiz/log";
+import { Testing } from "./testing";
+
+// Every test here drives real git in a repo of its own, dozens of processes
+// each: fast alone, but starved past bun's 5s default when the whole suite
+// runs in parallel on a busy machine.
+setDefaultTimeout(30_000);
+
+const CLI = join(import.meta.dirname, "index.ts");
+
+/** A repo of its own per test, so the four of them can run at once. */
+const setup = async () => {
+	const env = await Testing.open();
+	// A gate that passes, so the happy paths exercise merge rather than the
+	// fixture repo's (nonexistent) tests.
+	await env.fs.write(
+		join(env.root, "arbor.config.ts"),
+		`export default { preMerge: "true" };\n`,
+	);
+
+	/** Runs the CLI the way an agent does: a fresh process, a cwd, an exit code. */
+	const arbor = async (cwd: string, ...args: string[]) => {
+		const { exitCode, stdout, stderr } = await env.ps.spawnCapture(
+			["bun", CLI, ...args],
+			{ cwd },
+		);
+		return { exitCode, stdout: color.strip(stdout), stderr };
+	};
+
+	const rows = async () =>
+		JSON.parse((await arbor(env.root, "list", "--json")).stdout) as {
+			task: string;
+			status: string;
+			lease: "held" | "stale" | "none";
+			worktree: string;
+		}[];
+
+	return { env, arbor, rows, [Symbol.asyncDispose]: () => env.disposeAsync() };
+};
+
+describe.concurrent("arbor", () => {
+	it("lands both trees on trunk without a merge when two agents work at once", async () => {
+		await using cli = await setup();
+		const { env, arbor, rows } = cli;
+
+		expect((await arbor(env.root, "add", "alpha")).exitCode).toBe(0);
+		expect((await arbor(env.root, "add", "beta")).exitCode).toBe(0);
+
+		const listed = await rows();
+		expect(listed.map((row) => row.task)).toEqual(["alpha", "beta"]);
+		const [alpha, beta] = listed.map((row) => row.worktree) as [string, string];
+		expect([alpha, beta]).not.toContain("");
+
+		// Each agent resumes a tree it did not create: a fresh thread starts here.
+		const claimed = await arbor(alpha, "claim", "alpha");
+		expect(claimed.exitCode).toBe(0);
+		expect(claimed.stdout).toContain("uncommitted: none");
+		await env.commit(alpha, "alpha.txt", "alpha\n", "add alpha");
+		const merged = await arbor(alpha, "merge");
+		expect(merged.exitCode).toBe(0);
+		expect(merged.stdout).toContain("merged alpha onto main");
+
+		// beta rebases onto a trunk that alpha moved out from under it.
+		expect((await arbor(beta, "claim", "beta")).exitCode).toBe(0);
+		await env.commit(beta, "beta.txt", "beta\n", "add beta");
+		expect((await arbor(beta, "merge")).exitCode).toBe(0);
+
+		const log = await env.gitCli(env.root, "log", "--oneline", "main");
+		expect(log).toContain("add alpha");
+		expect(log).toContain("add beta");
+		expect(
+			await env.gitCli(env.root, "rev-list", "--count", "--merges", "main"),
+		).toBe("0");
+
+		expect(await rows()).toEqual([]);
+		const removed = await arbor(env.root, "remove", "alpha");
+		expect(removed.exitCode).toBe(13);
+		expect(removed.stdout).toContain("already_removed");
+
+		// The journal outlives the tasks: both merges and the refused remove.
+		const journal = JSON.parse(
+			(await arbor(env.root, "log", "--json")).stdout,
+		) as { action: string; task: string | null; reason: string | null }[];
+		expect(journal).toMatchObject([
+			{ action: "add", task: "alpha", reason: null },
+			{ action: "add", task: "beta", reason: null },
+			{ action: "claim", task: "alpha", reason: null },
+			{ action: "merge", task: "alpha", reason: null },
+			{ action: "claim", task: "beta", reason: null },
+			{ action: "merge", task: "beta", reason: null },
+			{ action: "remove", task: "alpha", reason: "already_removed" },
+		]);
+	});
+
+	it("lands a stacked task in its parent's worktree, and the parent on trunk", async () => {
+		await using cli = await setup();
+		const { env, arbor, rows } = cli;
+
+		expect((await arbor(env.root, "add", "parent")).exitCode).toBe(0);
+		const parent = ensure.defined(
+			(await rows())[0]?.worktree,
+			"add did not record a worktree path",
+		);
+		await env.commit(parent, "parent.txt", "parent\n", "add parent");
+
+		// The parent hands out a part from inside its own tree, based on its own
+		// branch, so the part lands on it rather than on trunk.
+		expect(
+			(await arbor(parent, "add", "part", "--base", "task/parent")).exitCode,
+		).toBe(0);
+		const part = ensure.defined(
+			(await rows()).find((row) => row.task === "part")?.worktree,
+			"add did not record a worktree path",
+		);
+		await env.commit(part, "part.txt", "part\n", "add part");
+
+		const landed = await arbor(part, "merge");
+		expect(landed.exitCode).toBe(0);
+		expect(landed.stdout).toContain("merged part onto task/parent");
+		expect(landed.stdout).toContain(parent);
+		// The parent's own tree has the file, not just the branch.
+		expect(await env.fs.exists(join(part, "part.txt"))).toBe(false);
+		expect(await env.fs.exists(join(parent, "part.txt"))).toBe(true);
+		expect(
+			await env.gitCli(env.root, "log", "--oneline", "main"),
+		).not.toContain("add part");
+
+		// The parent then lands both commits on trunk with its own merge.
+		expect((await arbor(parent, "merge")).exitCode).toBe(0);
+		const log = await env.gitCli(env.root, "log", "--oneline", "main");
+		expect(log).toContain("add parent");
+		expect(log).toContain("add part");
+		expect(await rows()).toEqual([]);
+	});
+
+	it("lands the work when a second agent picks up an escalated tree", async () => {
+		await using cli = await setup();
+		const { env, arbor, rows } = cli;
+
+		// Tests pass only once the committed marker says so, which is how the
+		// first agent's merge fails for a reason the second agent can fix.
+		await env.fs.write(
+			join(env.root, "arbor.config.ts"),
+			`export default { preMerge: "grep -q ok status.txt" };\n`,
+		);
+		expect((await arbor(env.root, "add", "gamma")).exitCode).toBe(0);
+		const tree = ensure.defined(
+			(await rows())[0]?.worktree,
+			"add did not record a worktree path",
+		);
+
+		expect((await arbor(tree, "claim", "gamma")).exitCode).toBe(0);
+		await env.commit(tree, "status.txt", "wrong\n", "add status");
+		const failed = await arbor(tree, "merge");
+		expect(failed.exitCode).not.toBe(0);
+		expect(
+			await env.gitCli(env.root, "log", "--oneline", "main"),
+		).not.toContain("add status");
+		expect(
+			(await arbor(tree, "escalate", "cannot tell what ok means")).exitCode,
+		).toBe(0);
+
+		// Second agent, fresh thread: the escalated tree is still claimable, is
+		// someone's work again, and the earlier failure did not eat the whole
+		// merge budget.
+		const resumed = await arbor(tree, "claim", "gamma");
+		expect(resumed.exitCode).toBe(0);
+		expect(resumed.stdout).toContain("status:   working (was escalated)");
+		expect(resumed.stdout).toContain("attempts: 1");
+		await env.commit(tree, "status.txt", "ok\n", "fix status");
+		const merged = await arbor(tree, "merge");
+		expect(merged.exitCode).toBe(0);
+		expect(merged.stdout).toContain("merged gamma onto main");
+		expect(await env.gitCli(env.root, "log", "--oneline", "main")).toContain(
+			"fix status",
+		);
+	});
+
+	it("reports the uncommitted work and lands it when an agent dies mid-task", async () => {
+		await using cli = await setup();
+		const { env, arbor, rows } = cli;
+
+		expect((await arbor(env.root, "add", "delta")).exitCode).toBe(0);
+		const tree = ensure.defined(
+			(await rows())[0]?.worktree,
+			"add did not record a worktree path",
+		);
+
+		// The first agent claims, writes, and never comes back: the record keeps
+		// a lease whose pid died with the process.
+		expect((await arbor(tree, "claim", "delta")).exitCode).toBe(0);
+		await env.fs.write(join(tree, "delta.txt"), "half done\n");
+		expect((await rows())[0]?.lease).toBe("stale");
+
+		// Second agent: the dead lease does not block the claim, and the
+		// half-finished file is reported rather than silently inherited.
+		const resumed = await arbor(tree, "claim", "delta");
+		expect(resumed.exitCode).toBe(0);
+		expect(resumed.stdout).toContain("uncommitted (1)");
+		expect(resumed.stdout).toContain("delta.txt");
+
+		await env.commit(tree, "delta.txt", "finished\n", "finish delta");
+		expect((await arbor(tree, "merge")).exitCode).toBe(0);
+		expect(await env.gitCli(env.root, "log", "--oneline", "main")).toContain(
+			"finish delta",
+		);
+	});
+
+	it("lands the tree on a retry when an agent is killed mid-merge", async () => {
+		await using cli = await setup();
+		const { env, arbor, rows } = cli;
+
+		// SIGKILL from inside the test gate: the first merge dies after rebasing
+		// and before trunk moves, holding both the lease and the merge lock. The
+		// marker file makes it happen exactly once, so the retry can pass.
+		const die = join(env.root, "die");
+		await env.fs.write(
+			join(env.root, "arbor.config.ts"),
+			`export default { preMerge: "if [ -f ${die} ]; then rm ${die}; kill -9 $PPID; fi" };\n`,
+		);
+		await env.fs.write(die, "");
+		expect((await arbor(env.root, "add", "epsilon")).exitCode).toBe(0);
+		const tree = ensure.defined(
+			(await rows())[0]?.worktree,
+			"add did not record a worktree path",
+		);
+
+		expect((await arbor(tree, "claim", "epsilon")).exitCode).toBe(0);
+		await env.commit(tree, "epsilon.txt", "epsilon\n", "add epsilon");
+		expect((await arbor(tree, "merge")).exitCode).not.toBe(0);
+		expect(await env.fs.exists(die)).toBe(false);
+
+		const stalled = (await rows())[0];
+		expect(stalled?.status).toBe("merging");
+		expect(stalled?.lease).toBe("stale");
+		expect(
+			await env.gitCli(env.root, "log", "--oneline", "main"),
+		).not.toContain("add epsilon");
+		expect(await env.fs.exists(join(env.arborDir, "merge.lock"))).toBe(true);
+
+		// Second agent: the abandoned lock is stolen rather than waited out.
+		const resumed = await arbor(tree, "claim", "epsilon");
+		expect(resumed.exitCode).toBe(0);
+		expect(resumed.stdout).toContain("status:   merging");
+		const merged = await arbor(tree, "merge");
+		expect(merged.exitCode).toBe(0);
+		expect(merged.stdout).toContain("merged epsilon onto main");
+		expect(await env.gitCli(env.root, "log", "--oneline", "main")).toContain(
+			"add epsilon",
+		);
+		expect(await rows()).toEqual([]);
+	});
+});