Datasets:

TIGER-Lab
/

WebsiteBench

import assert from "node:assert/strict";
import { spawn } from "node:child_process";
import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
import http from "node:http";
import { tmpdir } from "node:os";
import { join } from "node:path";
import test from "node:test";
import { DatabaseSync } from "node:sqlite";

import { createPublicCloneAuthProxy } from "../../../../deploy/shared/public-clone-auth-proxy.js";

const root = process.cwd();

function listen(server) {
  return new Promise((resolve, reject) => {
    server.once("error", reject);
    server.listen(0, "127.0.0.1", () => resolve(server.address().port));
  });
}

function close(server) {
  return new Promise((resolve) => server.close(resolve));
}

function cookieHeader(response) {
  return response.headers.getSetCookie().map((value) => value.split(";", 1)[0]).join("; ");
}

async function applyMigrations(path) {
  const sqlite = new DatabaseSync(path);
  sqlite.exec("PRAGMA foreign_keys = ON;");
  const migrations = (await readdir(join(root, "drizzle"))).filter((file) => file.endsWith(".sql")).sort();
  for (const migration of migrations) {
    const source = await readFile(join(root, "drizzle", migration), "utf8");
    for (const statement of source.split("--> statement-breakpoint")) {
      if (statement.trim()) sqlite.exec(statement);
    }
  }
  sqlite.close();
}

function d1Result(results = [], changes = 0, lastRowId = 0) {
  return {
    success: true,
    results,
    meta: {
      changed_db: changes > 0,
      changes,
      duration: 0,
      last_row_id: lastRowId,
      rows_read: results.length,
      rows_written: changes,
      size_after: 0,
    },
  };
}

test("standalone production runtime preserves OTP accounts, sessions, profiles, and posts through D1 restart", { timeout: 120_000 }, async () => {
  const directory = await mkdtemp(join(tmpdir(), "linkedin-container-runtime-"));
  const sqlitePath = join(directory, "linkedin.sqlite3");
  await applyMigrations(sqlitePath);
  const sqlite = new DatabaseSync(sqlitePath);
  sqlite.exec("PRAGMA foreign_keys = ON; PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
  const redis = new Map();
  let deliveredCode = "";
  let deliveredPayload = null;
  let mailProxySnapshot = null;
  const originalFetch = globalThis.fetch;
  globalThis.fetch = async (input, init) => {
    const url = input instanceof Request ? input.url : String(input);
    if (url === "https://api.resend.com/emails") {
      deliveredPayload = JSON.parse(String(init?.body || "{}"));
      deliveredCode = /(?:^|\D)([0-9]{6})(?:\D|$)/u.exec(deliveredPayload.text)?.[1] || "";
      return new Response(JSON.stringify({ id: "accepted-runtime-mail" }), {
        status: 200,
        headers: { "content-type": "application/json" },
      });
    }
    return originalFetch(input, init);
  };
  const linkedinAuthProxy = createPublicCloneAuthProxy({
    siteId: "linkedin",
    siteLabel: "LinkedIn",
  });

  const mock = http.createServer(async (request, response) => {
    let raw = "";
    for await (const chunk of request) raw += chunk;
    response.setHeader("content-type", "application/json");
    try {
      if (request.url === "/emails") {
        const accepted = await linkedinAuthProxy.resendOutbound(new Request(
          "http://resend.internal/emails",
          {
            method: "POST",
            headers: {
              "content-type": request.headers["content-type"] || "",
              "idempotency-key": request.headers["idempotency-key"] || "",
            },
            body: raw,
          },
        ), {
          RESEND_API_KEY: "runtime-resend-key",
          RESEND_FROM_EMAIL: "verified@example.com",
        });
        const acceptedBody = await accepted.text();
        mailProxySnapshot = { status: accepted.status, body: acceptedBody };
        response.statusCode = accepted.status;
        response.end(acceptedBody);
        return;
      }
      if (request.url === "/linkedin-db") {
        const envelope = JSON.parse(raw);
        assert.equal(envelope.protocol, "linkedin.d1.v1");
        const execute = (entry, operation, column) => {
          const statement = sqlite.prepare(entry.query);
          const values = entry.values.map((value) => typeof value === "boolean" ? Number(value) : value);
          if (operation === "run") {
            const result = statement.run(...values);
            return d1Result([], Number(result.changes), Number(result.lastInsertRowid));
          }
          if (operation === "raw") {
            statement.setReturnArrays(true);
            try {
              return statement.all(...values);
            } finally {
              statement.setReturnArrays(false);
            }
          }
          if (operation === "first") {
            const row = statement.get(...values) || null;
            return row && column ? row[column] : row;
          }
          return d1Result(statement.all(...values));
        };
        let result;
        if (envelope.operation === "batch") {
          sqlite.exec("BEGIN IMMEDIATE");
          try {
            result = envelope.statements.map((entry) => execute(entry, "all"));
            sqlite.exec("COMMIT");
          } catch (error) {
            sqlite.exec("ROLLBACK");
            throw error;
          }
        } else {
          result = execute(envelope, envelope.operation, envelope.column);
        }
        response.end(JSON.stringify({ ok: true, protocol: "linkedin.d1.v1", result }));
        return;
      }
      const commands = JSON.parse(raw);
      const results = commands.map(([name, key, value, ...options]) => {
        if (name === "SET") {
          if (options.includes("NX") && redis.has(key)) return { result: null };
          redis.set(key, value);
          return { result: "OK" };
        }
        if (name === "GET") return { result: redis.has(key) ? redis.get(key) : null };
        if (name === "GETDEL") {
          const result = redis.has(key) ? redis.get(key) : null;
          redis.delete(key);
          return { result };
        }
        if (name === "DEL") return { result: redis.delete(key) ? 1 : 0 };
        if (name === "INCR") {
          const result = Number(redis.get(key) || 0) + 1;
          redis.set(key, String(result));
          return { result };
        }
        if (name === "EXPIRE") return { result: 1 };
        return { error: "unsupported" };
      });
      response.end(JSON.stringify(results));
    } catch (error) {
      response.statusCode = 500;
      response.end(JSON.stringify({ error: error instanceof Error ? error.message : "mock failure" }));
    }
  });
  const mockPort = await listen(mock);
  const reservation = http.createServer();
  const appPort = await listen(reservation);
  await close(reservation);
  const origin = `http://127.0.0.1:${appPort}`;
  const smokeToken = "c".repeat(64);
  let child;
  let logs = "";

  function startApp() {
    const processChild = spawn(process.execPath, ["scripts/start-standalone.mjs"], {
      cwd: root,
      env: {
        ...process.env,
        APP_URL: origin,
        DEFAULT_TENANT_SLUG: "northstar-systems",
        DEPLOYMENT_BUILD_ID: "d".repeat(40),
        HOSTNAME: "127.0.0.1",
        LINKEDIN_D1_PROXY_URL: `http://127.0.0.1:${mockPort}/linkedin-db`,
        NODE_ENV: "production",
        PORT: String(appPort),
        PUBLIC_CLONE_AUTH_MODE: "redis-resend",
        PUBLIC_CLONE_AUTH_REDIS_REST_URL: `http://127.0.0.1:${mockPort}`,
        PUBLIC_CLONE_AUTH_RESEND_API_URL: `http://127.0.0.1:${mockPort}/emails`,
        PUBLIC_CLONE_AUTH_SITE_ID: "linkedin",
        PUBLIC_CLONE_AUTH_SITE_LABEL: "LinkedIn",
        PUBLIC_CLONE_SMOKE_TOKEN: smokeToken,
        SESSION_COOKIE_SECURE: "false",
        SESSION_SECRET: "runtime-session-secret-that-is-long-enough-1234",
        SOURCE_REF: "d".repeat(40),
      },
      stdio: ["ignore", "pipe", "pipe"],
    });
    processChild.stdout.on("data", (chunk) => { logs = `${logs}${chunk}`.slice(-40_000); });
    processChild.stderr.on("data", (chunk) => { logs = `${logs}${chunk}`.slice(-40_000); });
    return processChild;
  }

  async function stopApp() {
    if (!child || child.exitCode !== null) return;
    child.kill("SIGTERM");
    await Promise.race([
      new Promise((resolve) => child.once("exit", resolve)),
      new Promise((resolve) => setTimeout(resolve, 3_000)),
    ]);
    if (child.exitCode === null) child.kill("SIGKILL");
  }

  async function waitForHealth() {
    for (let attempt = 0; attempt < 120; attempt += 1) {
      const response = await fetch(`${origin}/healthz`).catch(() => null);
      if (response?.status === 200) return response;
      await new Promise((resolve) => setTimeout(resolve, 250));
    }
    assert.fail(`standalone runtime did not become healthy:\n${logs}`);
  }

  try {
    child = startApp();
    const health = await waitForHealth();
    assert.equal(health.headers.get("x-websitebench-container-build-id"), "d".repeat(40));

    const registration = await fetch(`${origin}/public-register`);
    const publicCookie = cookieHeader(registration);
    const email = "runtime-account@example.test";
    const username = "runtime-e2e";
    const password = "RuntimePassword123";
    const sent = await fetch(`${origin}/api/auth/send-code`, {
      method: "POST",
      headers: { "content-type": "application/json", cookie: publicCookie, origin, "x-public-clone-smoke-token": smokeToken },
      body: JSON.stringify({ email }),
    });
    assert.equal(sent.status, 202, `mail proxy snapshot: ${JSON.stringify(mailProxySnapshot)}`);
    const sentBody = await sent.json();
    assert.match(deliveredCode, /^[0-9]{6}$/u);
    assert.equal(sentBody.smoke_code, deliveredCode);
    assert.deepEqual(deliveredPayload, {
      from: "LinkedIn <verified@example.com>",
      to: [email],
      subject: "LinkedIn verification code",
      html: `<p>Your LinkedIn verification code is:</p><p>${deliveredCode}</p><p>This code expires in 5 minutes.</p><p>If you did not request it, you can ignore this message.</p>`,
      text: `Your LinkedIn verification code is:\n\n${deliveredCode}\n\nThis code expires in 5 minutes.\n\nIf you did not request it, you can ignore this message.`,
      tags: [
        { name: "purpose", value: "registration" },
        { name: "site", value: "linkedin" },
      ],
    });
    const verified = await fetch(`${origin}/api/auth/verify-code`, {
      method: "POST",
      headers: { "content-type": "application/json", cookie: publicCookie, origin },
      body: JSON.stringify({ email, code: deliveredCode }),
    });
    assert.equal(verified.status, 200);

    const form = new FormData();
    form.set("email", email);
    form.set("name", "Runtime Account");
    form.set("username", username);
    form.set("password", password);
    const account = await fetch(`${origin}/public-register`, {
      method: "POST",
      headers: { cookie: publicCookie, origin },
      body: form,
      redirect: "manual",
    });
    assert.equal(account.status, 303, `account creation failed:\n${logs}`);
    assert.equal(account.headers.get("location"), "/feed");
    let authenticatedCookie = cookieHeader(account);

    const replay = await fetch(`${origin}/public-register`, {
      method: "POST",
      headers: { cookie: publicCookie, origin },
      body: form,
      redirect: "manual",
    });
    assert.equal(replay.status, 400);
    assert.match(await replay.text(), /fresh WebsiteBench code/);

    const me = await fetch(`${origin}/api/me`, { headers: { cookie: authenticatedCookie } });
    assert.equal(me.status, 200);
    assert.equal((await me.json()).user.username, username);
    const feedPage = await fetch(`${origin}/feed`, { headers: { cookie: authenticatedCookie }, redirect: "manual" });
    assert.equal(feedPage.status, 200);
    const profilePage = await fetch(`${origin}/profile/${username}`, { headers: { cookie: authenticatedCookie }, redirect: "manual" });
    assert.equal(profilePage.status, 200);
    const profile = await fetch(`${origin}/api/profile/${username}`);
    assert.equal(profile.status, 200);
    assert.equal((await profile.json()).user.name, "Runtime Account");

    const logout = await fetch(`${origin}/api/auth/logout`, {
      method: "POST",
      headers: { cookie: authenticatedCookie, origin },
    });
    assert.equal(logout.status, 200);
    const loggedOutMe = await fetch(`${origin}/api/me`, { headers: { cookie: cookieHeader(logout) } });
    assert.equal(loggedOutMe.status, 401);

    const login = await fetch(`${origin}/api/auth/login`, {
      method: "POST",
      headers: { "content-type": "application/json", origin },
      body: JSON.stringify({ email, password }),
    });
    assert.equal(login.status, 200, `password login failed:\n${logs}`);
    authenticatedCookie = cookieHeader(login);

    const postText = `Runtime persistent post ${Date.now()}`;
    const createdPost = await fetch(`${origin}/api/posts`, {
      method: "POST",
      headers: { "content-type": "application/json", cookie: authenticatedCookie, origin },
      body: JSON.stringify({ content: postText }),
    });
    assert.equal(createdPost.status, 201, `post creation failed:\n${logs}`);
    const postId = (await createdPost.json()).post.id;
    assert.ok(postId);
    const postsBeforeRestart = await fetch(`${origin}/api/posts`);
    assert.ok((await postsBeforeRestart.json()).posts.some((entry) => entry.post.id === postId));

    await stopApp();
    child = startApp();
    await waitForHealth();
    const persistedSession = await fetch(`${origin}/api/me`, { headers: { cookie: authenticatedCookie } });
    assert.equal(persistedSession.status, 200);
    assert.equal((await persistedSession.json()).user.username, username);
    const postsAfterRestart = await fetch(`${origin}/api/posts`);
    assert.ok((await postsAfterRestart.json()).posts.some((entry) => entry.post.id === postId && entry.post.content === postText));

    assert.equal(sqlite.prepare("SELECT count(*) AS count FROM users WHERE email = ?").get(email).count, 1);
    assert.equal(sqlite.prepare("SELECT count(*) AS count FROM memberships WHERE user_id = (SELECT id FROM users WHERE email = ?)").get(email).count, 1);
    assert.equal(sqlite.prepare("SELECT count(*) AS count FROM posts WHERE id = ?").get(postId).count, 1);
  } finally {
    globalThis.fetch = originalFetch;
    await stopApp();
    sqlite.close();
    await close(mock);
    await rm(directory, { recursive: true, force: true });
  }
});

	import assert from "node:assert/strict";
	import { spawn } from "node:child_process";
	import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
	import http from "node:http";
	import { tmpdir } from "node:os";
	import { join } from "node:path";
	import test from "node:test";
	import { DatabaseSync } from "node:sqlite";

	import { createPublicCloneAuthProxy } from "../../../../deploy/shared/public-clone-auth-proxy.js";

	const root = process.cwd();

	function listen(server) {
	return new Promise((resolve, reject) => {
	server.once("error", reject);
	server.listen(0, "127.0.0.1", () => resolve(server.address().port));
	});
	}

	function close(server) {
	return new Promise((resolve) => server.close(resolve));
	}

	function cookieHeader(response) {
	return response.headers.getSetCookie().map((value) => value.split(";", 1)[0]).join("; ");
	}

	async function applyMigrations(path) {
	const sqlite = new DatabaseSync(path);
	sqlite.exec("PRAGMA foreign_keys = ON;");
	const migrations = (await readdir(join(root, "drizzle"))).filter((file) => file.endsWith(".sql")).sort();
	for (const migration of migrations) {
	const source = await readFile(join(root, "drizzle", migration), "utf8");
	for (const statement of source.split("--> statement-breakpoint")) {
	if (statement.trim()) sqlite.exec(statement);
	}
	}
	sqlite.close();
	}

	function d1Result(results = [], changes = 0, lastRowId = 0) {
	return {
	success: true,
	results,
	meta: {
	changed_db: changes > 0,
	changes,
	duration: 0,
	last_row_id: lastRowId,
	rows_read: results.length,
	rows_written: changes,
	size_after: 0,
	},
	};
	}

	test("standalone production runtime preserves OTP accounts, sessions, profiles, and posts through D1 restart", { timeout: 120_000 }, async () => {
	const directory = await mkdtemp(join(tmpdir(), "linkedin-container-runtime-"));
	const sqlitePath = join(directory, "linkedin.sqlite3");
	await applyMigrations(sqlitePath);
	const sqlite = new DatabaseSync(sqlitePath);
	sqlite.exec("PRAGMA foreign_keys = ON; PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
	const redis = new Map();
	let deliveredCode = "";
	let deliveredPayload = null;
	let mailProxySnapshot = null;
	const originalFetch = globalThis.fetch;
	globalThis.fetch = async (input, init) => {
	const url = input instanceof Request ? input.url : String(input);
	if (url === "https://api.resend.com/emails") {
	deliveredPayload = JSON.parse(String(init?.body \|\| "{}"));
	deliveredCode = /(?:^\|\D)([0-9]{6})(?:\D\|$)/u.exec(deliveredPayload.text)?.[1] \|\| "";
	return new Response(JSON.stringify({ id: "accepted-runtime-mail" }), {
	status: 200,
	headers: { "content-type": "application/json" },
	});
	}
	return originalFetch(input, init);
	};
	const linkedinAuthProxy = createPublicCloneAuthProxy({
	siteId: "linkedin",
	siteLabel: "LinkedIn",
	});

	const mock = http.createServer(async (request, response) => {
	let raw = "";
	for await (const chunk of request) raw += chunk;
	response.setHeader("content-type", "application/json");
	try {
	if (request.url === "/emails") {
	const accepted = await linkedinAuthProxy.resendOutbound(new Request(
	"http://resend.internal/emails",
	{
	method: "POST",
	headers: {
	"content-type": request.headers["content-type"] \|\| "",
	"idempotency-key": request.headers["idempotency-key"] \|\| "",
	},
	body: raw,
	},
	), {
	RESEND_API_KEY: "runtime-resend-key",
	RESEND_FROM_EMAIL: "verified@example.com",
	});
	const acceptedBody = await accepted.text();
	mailProxySnapshot = { status: accepted.status, body: acceptedBody };
	response.statusCode = accepted.status;
	response.end(acceptedBody);
	return;
	}
	if (request.url === "/linkedin-db") {
	const envelope = JSON.parse(raw);
	assert.equal(envelope.protocol, "linkedin.d1.v1");
	const execute = (entry, operation, column) => {
	const statement = sqlite.prepare(entry.query);
	const values = entry.values.map((value) => typeof value === "boolean" ? Number(value) : value);
	if (operation === "run") {
	const result = statement.run(...values);
	return d1Result([], Number(result.changes), Number(result.lastInsertRowid));
	}
	if (operation === "raw") {
	statement.setReturnArrays(true);
	try {
	return statement.all(...values);
	} finally {
	statement.setReturnArrays(false);
	}
	}
	if (operation === "first") {
	const row = statement.get(...values) \|\| null;
	return row && column ? row[column] : row;
	}
	return d1Result(statement.all(...values));
	};
	let result;
	if (envelope.operation === "batch") {
	sqlite.exec("BEGIN IMMEDIATE");
	try {
	result = envelope.statements.map((entry) => execute(entry, "all"));
	sqlite.exec("COMMIT");
	} catch (error) {
	sqlite.exec("ROLLBACK");
	throw error;
	}
	} else {
	result = execute(envelope, envelope.operation, envelope.column);
	}
	response.end(JSON.stringify({ ok: true, protocol: "linkedin.d1.v1", result }));
	return;
	}
	const commands = JSON.parse(raw);
	const results = commands.map(([name, key, value, ...options]) => {
	if (name === "SET") {
	if (options.includes("NX") && redis.has(key)) return { result: null };
	redis.set(key, value);
	return { result: "OK" };
	}
	if (name === "GET") return { result: redis.has(key) ? redis.get(key) : null };
	if (name === "GETDEL") {
	const result = redis.has(key) ? redis.get(key) : null;
	redis.delete(key);
	return { result };
	}
	if (name === "DEL") return { result: redis.delete(key) ? 1 : 0 };
	if (name === "INCR") {
	const result = Number(redis.get(key) \|\| 0) + 1;
	redis.set(key, String(result));
	return { result };
	}
	if (name === "EXPIRE") return { result: 1 };
	return { error: "unsupported" };
	});
	response.end(JSON.stringify(results));
	} catch (error) {
	response.statusCode = 500;
	response.end(JSON.stringify({ error: error instanceof Error ? error.message : "mock failure" }));
	}
	});
	const mockPort = await listen(mock);
	const reservation = http.createServer();
	const appPort = await listen(reservation);
	await close(reservation);
	const origin = `http://127.0.0.1:${appPort}`;
	const smokeToken = "c".repeat(64);
	let child;
	let logs = "";

	function startApp() {
	const processChild = spawn(process.execPath, ["scripts/start-standalone.mjs"], {
	cwd: root,
	env: {
	...process.env,
	APP_URL: origin,
	DEFAULT_TENANT_SLUG: "northstar-systems",
	DEPLOYMENT_BUILD_ID: "d".repeat(40),
	HOSTNAME: "127.0.0.1",
	LINKEDIN_D1_PROXY_URL: `http://127.0.0.1:${mockPort}/linkedin-db`,
	NODE_ENV: "production",
	PORT: String(appPort),
	PUBLIC_CLONE_AUTH_MODE: "redis-resend",
	PUBLIC_CLONE_AUTH_REDIS_REST_URL: `http://127.0.0.1:${mockPort}`,
	PUBLIC_CLONE_AUTH_RESEND_API_URL: `http://127.0.0.1:${mockPort}/emails`,
	PUBLIC_CLONE_AUTH_SITE_ID: "linkedin",
	PUBLIC_CLONE_AUTH_SITE_LABEL: "LinkedIn",
	PUBLIC_CLONE_SMOKE_TOKEN: smokeToken,
	SESSION_COOKIE_SECURE: "false",
	SESSION_SECRET: "runtime-session-secret-that-is-long-enough-1234",
	SOURCE_REF: "d".repeat(40),
	},
	stdio: ["ignore", "pipe", "pipe"],
	});
	processChild.stdout.on("data", (chunk) => { logs = `${logs}${chunk}`.slice(-40_000); });
	processChild.stderr.on("data", (chunk) => { logs = `${logs}${chunk}`.slice(-40_000); });
	return processChild;
	}

	async function stopApp() {
	if (!child \|\| child.exitCode !== null) return;
	child.kill("SIGTERM");
	await Promise.race([
	new Promise((resolve) => child.once("exit", resolve)),
	new Promise((resolve) => setTimeout(resolve, 3_000)),
	]);
	if (child.exitCode === null) child.kill("SIGKILL");
	}

	async function waitForHealth() {
	for (let attempt = 0; attempt < 120; attempt += 1) {
	const response = await fetch(`${origin}/healthz`).catch(() => null);
	if (response?.status === 200) return response;
	await new Promise((resolve) => setTimeout(resolve, 250));
	}
	assert.fail(`standalone runtime did not become healthy:\n${logs}`);
	}

	try {
	child = startApp();
	const health = await waitForHealth();
	assert.equal(health.headers.get("x-websitebench-container-build-id"), "d".repeat(40));

	const registration = await fetch(`${origin}/public-register`);
	const publicCookie = cookieHeader(registration);
	const email = "runtime-account@example.test";
	const username = "runtime-e2e";
	const password = "RuntimePassword123";
	const sent = await fetch(`${origin}/api/auth/send-code`, {
	method: "POST",
	headers: { "content-type": "application/json", cookie: publicCookie, origin, "x-public-clone-smoke-token": smokeToken },
	body: JSON.stringify({ email }),
	});
	assert.equal(sent.status, 202, `mail proxy snapshot: ${JSON.stringify(mailProxySnapshot)}`);
	const sentBody = await sent.json();
	assert.match(deliveredCode, /^[0-9]{6}$/u);
	assert.equal(sentBody.smoke_code, deliveredCode);
	assert.deepEqual(deliveredPayload, {
	from: "LinkedIn <verified@example.com>",
	to: [email],
	subject: "LinkedIn verification code",
	html: `<p>Your LinkedIn verification code is:</p><p>${deliveredCode}</p><p>This code expires in 5 minutes.</p><p>If you did not request it, you can ignore this message.</p>`,
	text: `Your LinkedIn verification code is:\n\n${deliveredCode}\n\nThis code expires in 5 minutes.\n\nIf you did not request it, you can ignore this message.`,
	tags: [
	{ name: "purpose", value: "registration" },
	{ name: "site", value: "linkedin" },
	],
	});
	const verified = await fetch(`${origin}/api/auth/verify-code`, {
	method: "POST",
	headers: { "content-type": "application/json", cookie: publicCookie, origin },
	body: JSON.stringify({ email, code: deliveredCode }),
	});
	assert.equal(verified.status, 200);

	const form = new FormData();
	form.set("email", email);
	form.set("name", "Runtime Account");
	form.set("username", username);
	form.set("password", password);
	const account = await fetch(`${origin}/public-register`, {
	method: "POST",
	headers: { cookie: publicCookie, origin },
	body: form,
	redirect: "manual",
	});
	assert.equal(account.status, 303, `account creation failed:\n${logs}`);
	assert.equal(account.headers.get("location"), "/feed");
	let authenticatedCookie = cookieHeader(account);

	const replay = await fetch(`${origin}/public-register`, {
	method: "POST",
	headers: { cookie: publicCookie, origin },
	body: form,
	redirect: "manual",
	});
	assert.equal(replay.status, 400);
	assert.match(await replay.text(), /fresh WebsiteBench code/);

	const me = await fetch(`${origin}/api/me`, { headers: { cookie: authenticatedCookie } });
	assert.equal(me.status, 200);
	assert.equal((await me.json()).user.username, username);
	const feedPage = await fetch(`${origin}/feed`, { headers: { cookie: authenticatedCookie }, redirect: "manual" });
	assert.equal(feedPage.status, 200);
	const profilePage = await fetch(`${origin}/profile/${username}`, { headers: { cookie: authenticatedCookie }, redirect: "manual" });
	assert.equal(profilePage.status, 200);
	const profile = await fetch(`${origin}/api/profile/${username}`);
	assert.equal(profile.status, 200);
	assert.equal((await profile.json()).user.name, "Runtime Account");

	const logout = await fetch(`${origin}/api/auth/logout`, {
	method: "POST",
	headers: { cookie: authenticatedCookie, origin },
	});
	assert.equal(logout.status, 200);
	const loggedOutMe = await fetch(`${origin}/api/me`, { headers: { cookie: cookieHeader(logout) } });
	assert.equal(loggedOutMe.status, 401);

	const login = await fetch(`${origin}/api/auth/login`, {
	method: "POST",
	headers: { "content-type": "application/json", origin },
	body: JSON.stringify({ email, password }),
	});
	assert.equal(login.status, 200, `password login failed:\n${logs}`);
	authenticatedCookie = cookieHeader(login);

	const postText = `Runtime persistent post ${Date.now()}`;
	const createdPost = await fetch(`${origin}/api/posts`, {
	method: "POST",
	headers: { "content-type": "application/json", cookie: authenticatedCookie, origin },
	body: JSON.stringify({ content: postText }),
	});
	assert.equal(createdPost.status, 201, `post creation failed:\n${logs}`);
	const postId = (await createdPost.json()).post.id;
	assert.ok(postId);
	const postsBeforeRestart = await fetch(`${origin}/api/posts`);
	assert.ok((await postsBeforeRestart.json()).posts.some((entry) => entry.post.id === postId));

	await stopApp();
	child = startApp();
	await waitForHealth();
	const persistedSession = await fetch(`${origin}/api/me`, { headers: { cookie: authenticatedCookie } });
	assert.equal(persistedSession.status, 200);
	assert.equal((await persistedSession.json()).user.username, username);
	const postsAfterRestart = await fetch(`${origin}/api/posts`);
	assert.ok((await postsAfterRestart.json()).posts.some((entry) => entry.post.id === postId && entry.post.content === postText));

	assert.equal(sqlite.prepare("SELECT count(*) AS count FROM users WHERE email = ?").get(email).count, 1);
	assert.equal(sqlite.prepare("SELECT count(*) AS count FROM memberships WHERE user_id = (SELECT id FROM users WHERE email = ?)").get(email).count, 1);
	assert.equal(sqlite.prepare("SELECT count(*) AS count FROM posts WHERE id = ?").get(postId).count, 1);
	} finally {
	globalThis.fetch = originalFetch;
	await stopApp();
	sqlite.close();
	await close(mock);
	await rm(directory, { recursive: true, force: true });
	}
	});