@cosmicdrift/kumiko-testing 0.295.0

package/LICENSE

@@ -0,0 +1,57 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor:             Marc Frost
+
+Licensed Work:        @cosmicdrift/kumiko-testing
+                      The Licensed Work is © 2026 Marc Frost.
+
+Additional Use Grant: 
+You may use the Licensed Work in production for any purpose, including 
+commercially, EXCEPT for the Restricted Use. 
+
+"Restricted Use" is defined as using the Licensed Work to provide a platform 
+or service to third parties that allows them to host, deploy, or run their 
+own applications built with the Licensed Work. This includes, but is not 
+limited to: managed hosting services, software-as-a-service (SaaS) platforms, 
+platform-as-a-service (PaaS), developer platforms, or any multi-tenant 
+managed offering of the Licensed Work.
+
+This restriction does not apply to the Licensor, any entity controlled by, 
+controlling, or under common control with the Licensor ("Affiliates"), or 
+contractors acting on their behalf. The Licensor remains free to use the 
+Licensed Work for any purpose, including for the operation of kumiko.rocks.
+
+Change Date:          2030-05-05
+Change License:       Apache License, Version 2.0
+
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative works, 
+redistribute, and make non-production use of the Licensed Work. The Licensor may 
+make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly 
+available distribution of the Licensed Work under this License, whichever comes 
+first, this License will convert to the Change License.
+
+This Business Source License governs use of the Licensed Work in all cases, except 
+as to any use that is explicitly granted in the Additional Use Grant above or 
+under the Change License after the Change Date.
+
+If your use of the Licensed Work does not comply with the requirements of this 
+License, you must cease use of the Licensed Work immediately.
+
+All copies of the Licensed Work, and all derivative works thereof, must include 
+this License.
+
+This License does not grant you any right, title, or interest in any trademark, 
+logo, or branding of the Licensor, except as required to comply with this License.
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON AN 
+“AS IS” BASIS. LICENSOR DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING 
+WITHOUT LIMITATION WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, 
+TITLE, AND NON-INFRINGEMENT. IN NO EVENT WILL LICENSOR BE LIABLE FOR ANY DAMAGES 
+ARISING OUT OF OR RELATED TO THIS LICENSE OR THE USE OF THE LICENSED WORK.

package/README.md

@@ -0,0 +1,49 @@
+# @cosmicdrift/kumiko-testing
+
+Test template for Kumiko apps. Test-only: never import it from production code.
+
+```ts
+import { seedTenant, setupAppTestStack } from "@cosmicdrift/kumiko-testing";
+
+const stack = await setupAppTestStack([myFeature]);
+const tenant = await seedTenant(stack, { users: 2 }); // light: no rows, own id/key/users
+const persisted = await seedTenant(stack, { persist: true }); // real rows via the dispatcher
+await tenant.api.writeOk("my-feature:write:thing:create", { title: "x" });
+```
+
+- `preload/{temporal,ci-log,scrub-env,env,real}`: bunfig `preload` entries. `scrub-env` removes
+  `PROVIDER_ENV_KEYS` (unit default); `env` adds the localhost service defaults (integration);
+  `real` refuses to run without `KUMIKO_REAL_PROVIDERS=1` and in CI, and keeps the keys.
+- `kumiko-testing bunfig [--dom] [--coverage]`: writes `bunfig.toml`,
+  `bunfig.integration.toml` and `bunfig.real.toml` (plus `bunfig.dom.toml`). `--dom` needs your own
+  `./test-setup/dom.preload.ts`.
+- `kumiko-testing integration [--parallel N] [--timings <file>]`: runs `*.integration.test.ts`
+  with the 15s budget. No `--no-isolate`; `--parallel` only when you ask for it.
+
+## E2E (`./e2e`, `./e2e/seed-route`)
+
+`@playwright/test` is an optional peer dependency; only the `./e2e` subpath imports it. The server side
+(`./e2e/seed-route`) never does.
+
+```ts
+// e2e/server.ts: mount the seed routes next to the app
+runDevApp({ features, auth: { admin }, extraRoutes: createE2eSeedRoutes() });
+
+// playwright.config.ts
+export default defineAppE2eConfig({ port: 4321 });
+
+// e2e/flow.spec.ts
+import { expect, test } from "@cosmicdrift/kumiko-testing/e2e";
+test("member sees the note", async ({ seedTenant, page }) => {
+  const tenant = await seedTenant({ users: 1, with: [seedNotes] });
+  await tenant.loginAs(page, tenant.members[0]!);
+});
+```
+
+- `defineAppE2eConfig({ port, env?, locale?, projects?, serverEntry?, testDir?, testMatch? })`: parallelism, retries, timeouts and
+  workers (`KUMIKO_E2E_WORKERS` overrides) are fixed by the template; projects cannot set them.
+- The seed routes answer only with `KUMIKO_TEST_SEED=1`, outside `NODE_ENV=production`, and with the
+  per-run `KUMIKO_TEST_SEED_TOKEN` in the `x-kumiko-test-seed` header. `defineAppE2eConfig` sets all three.
+- App roles: `createE2eSeedRoutes({ extraRoles: ["TenantMember"] })` lets `tenant.addUser(["TenantMember"])` seed them;
+  `SystemAdmin` is never seedable and makes the route builder throw.
+- A `SeedPart` receives `{ tenant }` and works against the in-process `seedTenant` and the HTTP tenant alike.

package/bin/kumiko-testing.ts

@@ -0,0 +1,76 @@
+#!/usr/bin/env bun
+// biome-ignore-all lint/suspicious/noConsole: CLI script, console is the interface.
+
+import { existsSync, writeFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { Glob } from "bun";
+import { BUNFIG_FILES, renderBunfigFiles } from "../src/bunfig";
+import { buildIntegrationTestArgs, selectIntegrationFiles } from "../src/integration-runner";
+
+const USAGE = `kumiko-testing <command>
+
+  bunfig [--dom] [--coverage] [--hoisted]  write bunfig.toml, bunfig.integration.toml and
+                                           bunfig.real.toml (plus bunfig.dom.toml with --dom);
+                                           --hoisted adds [install] linker = "hoisted"
+  integration [--parallel N]               run every *.integration.test.ts under the cwd
+              [--timings <file>] [--update-timings]
+`;
+
+function runBunfig(args: readonly string[]): number {
+  const { values } = parseArgs({
+    args: [...args],
+    options: {
+      dom: { type: "boolean" },
+      coverage: { type: "boolean" },
+      hoisted: { type: "boolean" },
+    },
+    strict: true,
+  });
+  const files = renderBunfigFiles({
+    dom: values.dom === true,
+    coverage: values.coverage === true,
+    ...(values.hoisted === true && { install: { linker: "hoisted" } }),
+  });
+  for (const [name, content] of Object.entries(files)) {
+    writeFileSync(name, content);
+    console.log(`wrote ${name}`);
+  }
+  return 0;
+}
+
+async function runIntegration(args: readonly string[]): Promise<number> {
+  const { values } = parseArgs({
+    args: [...args],
+    options: {
+      parallel: { type: "string" },
+      timings: { type: "string" },
+      "update-timings": { type: "boolean" },
+    },
+    strict: true,
+  });
+  if (!existsSync(BUNFIG_FILES.integration)) {
+    console.error(`${BUNFIG_FILES.integration} not found - run \`kumiko-testing bunfig\` first`);
+    return 1;
+  }
+  const files = selectIntegrationFiles(
+    await Array.fromAsync(new Glob("**/*.integration.test.ts").scan({ cwd: process.cwd() })),
+  );
+  if (files.length === 0) {
+    console.error("no *.integration.test.ts files found");
+    return 1;
+  }
+  const testArgs = buildIntegrationTestArgs({
+    files,
+    ...(values.parallel !== undefined && { parallel: Number(values.parallel) }),
+    ...(values.timings !== undefined && { timings: values.timings }),
+    ...(values["update-timings"] === true && { updateTimings: true }),
+  });
+  const proc = Bun.spawn(["bun", ...testArgs], { stdio: ["inherit", "inherit", "inherit"] });
+  return proc.exited;
+}
+
+const [command, ...rest] = process.argv.slice(2);
+if (command === "bunfig") process.exit(runBunfig(rest));
+if (command === "integration") process.exit(await runIntegration(rest));
+console.error(USAGE);
+process.exit(2);

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@cosmicdrift/kumiko-testing",
+  "version": "0.295.0",
+  "description": "Test template for Kumiko apps: per-flow seedTenant, app test stack, canonical test preloads, bunfig generator and integration runner.",
+  "license": "BUSL-1.1",
+  "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CosmicDriftGameStudio/kumiko-framework.git",
+    "directory": "packages/testing"
+  },
+  "bugs": {
+    "url": "https://github.com/CosmicDriftGameStudio/kumiko-framework/issues"
+  },
+  "homepage": "https://kumiko.rocks",
+  "type": "module",
+  "kumiko": {
+    "runtime": "test"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./bunfig": {
+      "types": "./src/bunfig.ts",
+      "default": "./src/bunfig.ts"
+    },
+    "./preload/temporal": {
+      "types": "./src/preload/temporal.ts",
+      "default": "./src/preload/temporal.ts"
+    },
+    "./preload/ci-log": {
+      "types": "./src/preload/ci-log.ts",
+      "default": "./src/preload/ci-log.ts"
+    },
+    "./preload/scrub-env": {
+      "types": "./src/preload/scrub-env.ts",
+      "default": "./src/preload/scrub-env.ts"
+    },
+    "./preload/env": {
+      "types": "./src/preload/env.ts",
+      "default": "./src/preload/env.ts"
+    },
+    "./preload/real": {
+      "types": "./src/preload/real.ts",
+      "default": "./src/preload/real.ts"
+    },
+    "./scaffold": {
+      "types": "./src/scaffold.ts",
+      "default": "./src/scaffold.ts"
+    },
+    "./e2e": {
+      "types": "./src/e2e/index.ts",
+      "default": "./src/e2e/index.ts"
+    },
+    "./e2e/seed-route": {
+      "types": "./src/e2e/seed-route.ts",
+      "default": "./src/e2e/seed-route.ts"
+    }
+  },
+  "bin": {
+    "kumiko-testing": "./bin/kumiko-testing.ts"
+  },
+  "dependencies": {
+    "@cosmicdrift/kumiko-bundled-features": "0.295.0",
+    "@cosmicdrift/kumiko-dev-server": "0.295.0",
+    "@cosmicdrift/kumiko-framework": "0.295.0",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.62.1"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.62.1"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "bin",
+    "!src/**/__tests__/**",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/bunfig.ts

@@ -0,0 +1,94 @@
+export const TEST_TIMEOUT_MS = {
+  unit: 5000,
+  integration: 15000,
+  dom: 15000,
+  // Real providers add network round-trips and provider-side latency the local stack never has.
+  real: 120000,
+} as const;
+
+export const BUNFIG_FILES = {
+  unit: "bunfig.toml",
+  integration: "bunfig.integration.toml",
+  real: "bunfig.real.toml",
+  dom: "bunfig.dom.toml",
+} as const;
+
+export type BunfigVariant = "unit" | "integration" | "real";
+
+export type BunfigOptions = {
+  readonly dom?: boolean;
+  readonly coverage?: boolean;
+  readonly install?: { readonly linker: "hoisted" };
+};
+
+const PRELOAD_PREFIX = "@cosmicdrift/kumiko-testing/preload";
+const DOM_PRELOAD = "./test-setup/dom.preload.ts";
+
+const PRELOADS = {
+  unit: [`${PRELOAD_PREFIX}/temporal`, `${PRELOAD_PREFIX}/scrub-env`],
+  integration: [`${PRELOAD_PREFIX}/temporal`, `${PRELOAD_PREFIX}/env`],
+  real: [`${PRELOAD_PREFIX}/temporal`, `${PRELOAD_PREFIX}/real`],
+} as const satisfies Record<BunfigVariant, readonly string[]>;
+
+const ALWAYS_IGNORED = ["**/e2e/**", "**/*.spec.ts", "**/*.spec.tsx", "**/dist/**"] as const;
+
+const COVERAGE_IGNORED = ["**/scripts/**", "**/bin/**"] as const;
+
+function ignoredPaths(variant: BunfigVariant, dom: boolean): readonly string[] {
+  switch (variant) {
+    case "unit":
+      return [
+        "**/*.integration.test.ts",
+        "**/*.real.test.ts",
+        ...(dom ? [] : ["**/*.test.tsx"]),
+        ...ALWAYS_IGNORED,
+      ];
+    case "integration":
+      return ["**/*.real.test.ts", ...ALWAYS_IGNORED];
+    case "real":
+      return ["**/*.integration.test.ts", ...ALWAYS_IGNORED];
+  }
+}
+
+function tomlStringArray(key: string, items: readonly string[]): string {
+  return `${key} = [\n${items.map((item) => `  ${JSON.stringify(item)},`).join("\n")}\n]`;
+}
+
+export function renderBunfig(variant: BunfigVariant, opts: BunfigOptions = {}): string {
+  const dom = opts.dom === true;
+  if (dom && variant !== "unit") {
+    throw new Error(`bunfig option "dom" only applies to the unit variant, not "${variant}"`);
+  }
+  const preload = dom ? [...PRELOADS.unit, DOM_PRELOAD] : PRELOADS[variant];
+  const coverageDir = `coverage/${dom ? "dom" : variant}`;
+
+  const lines = [
+    `# Generated by kumiko-testing (${dom ? "dom" : variant}) - do not edit, regenerate with \`kumiko-testing bunfig\`.`,
+    "# bun ignores a [test] timeout key; the class budget is passed as --timeout by the runner scripts.",
+    ...(opts.install !== undefined
+      ? ["[install]", `linker = ${JSON.stringify(opts.install.linker)}`, ""]
+      : []),
+    "[test]",
+    tomlStringArray("preload", preload),
+    ...(opts.coverage === true
+      ? [
+          "coverage = true",
+          'coverageReporter = ["lcov"]',
+          `coverageDir = ${JSON.stringify(coverageDir)}`,
+          tomlStringArray("coveragePathIgnorePatterns", COVERAGE_IGNORED),
+        ]
+      : []),
+    tomlStringArray("pathIgnorePatterns", ignoredPaths(variant, dom)),
+  ];
+  return `${lines.join("\n")}\n`;
+}
+
+export function renderBunfigFiles(opts: BunfigOptions = {}): Readonly<Record<string, string>> {
+  const { dom, ...shared } = opts;
+  return {
+    [BUNFIG_FILES.unit]: renderBunfig("unit", shared),
+    [BUNFIG_FILES.integration]: renderBunfig("integration", shared),
+    [BUNFIG_FILES.real]: renderBunfig("real", shared),
+    ...(dom === true ? { [BUNFIG_FILES.dom]: renderBunfig("unit", { ...shared, dom: true }) } : {}),
+  };
+}

package/src/changes.json

@@ -0,0 +1,8 @@
+[
+  {
+    "version": "0.295.0",
+    "type": "improvement",
+    "title": "New kumiko-testing package with seedTenant, preloads, bunfig generator and integration runner",
+    "detail": "seedTenant gives each test its own tenant (light by default, persist: true writes real rows through the dispatcher), setupAppTestStack mounts the bundled features and the entity projection tables, the preload subpaths (temporal, ci-log, scrub-env, env, real) replace the per-repo test-setup copies and scrub provider API keys, renderBunfig generates the bunfig variants, and kumiko-testing integration runs the integration files with the 15s budget and opt-in parallelism.\nThe `./e2e` subpath is the Playwright core: defineAppE2eConfig fixes parallelism, retries, timeouts and workers centrally, the test fixture seeds a tenant per test through the token-gated `./e2e/seed-route` routes and logs the admin in, and the auth kit (loginViaApi, csrfFetch, createHttpApi, totpCode, waitForProjection) replaces the per-app copies. A SeedPart runs unchanged against the in-process stack and over HTTP.\nThe screenshot runner (runScreenshots, runMatrix, pinEnglishLocale) moves in from the samples: `SCREENSHOT_DIR` is required with no default path, so a run can never overwrite the committed docs images, and `screenshotSpecsIgnore()` keeps screenshot specs out of every normal e2e run. Scenarios no longer take `settleMs`; the runner waits until no data request is in flight and the page layout stops changing."
+  }
+]

package/src/e2e/auth-kit.ts

@@ -0,0 +1,151 @@
+import { currentTotpCode } from "@cosmicdrift/kumiko-bundled-features/auth-mfa/testing";
+import type { WriteErrorInfo } from "@cosmicdrift/kumiko-framework/errors";
+import { type APIRequestContext, type APIResponse, expect, type Page } from "@playwright/test";
+import { z } from "zod";
+import type { BoundApi } from "../seed-types";
+import { CSRF_COOKIE_NAME, CSRF_HEADER_NAME } from "./constants";
+
+export type LoginCredentials = { readonly email: string; readonly password: string };
+
+type ApiEndpoint = "/api/write" | "/api/query" | "/api/command";
+
+type ApiReply = { readonly status: number; readonly body: unknown };
+
+const successEnvelope = z.looseObject({
+  isSuccess: z.boolean().optional(),
+  data: z.unknown().optional(),
+  error: z.unknown().optional(),
+});
+const errorEnvelope = z.looseObject({ error: z.looseObject({ code: z.string() }) });
+
+export function csrfHeaderFromCookies(
+  cookies: readonly { readonly name: string; readonly value: string }[],
+): Record<string, string> {
+  const token = cookies.find((cookie) => cookie.name === CSRF_COOKIE_NAME)?.value;
+  return token === undefined ? {} : { [CSRF_HEADER_NAME]: token };
+}
+
+export async function csrfFetch(
+  request: APIRequestContext,
+  path: string,
+  data?: unknown,
+): Promise<APIResponse> {
+  const { cookies } = await request.storageState();
+  return request.post(path, { headers: csrfHeaderFromCookies(cookies), data });
+}
+
+export async function loginViaApi(
+  request: APIRequestContext,
+  credentials: LoginCredentials,
+): Promise<void> {
+  const response = await request.post("/api/auth/login", {
+    data: { email: credentials.email, password: credentials.password },
+  });
+  if (!response.ok()) {
+    throw new Error(
+      `loginViaApi(${credentials.email}): POST /api/auth/login -> ${response.status()} ${await response.text()}`,
+    );
+  }
+}
+
+export async function loginViaUi(page: Page, credentials: LoginCredentials): Promise<void> {
+  // seedTenant already logged the context in, and an authenticated session never renders /login.
+  await page.context().clearCookies();
+  await page.goto("/login");
+  await page.locator("#login-email").fill(credentials.email);
+  await page.locator("#login-password").fill(credentials.password);
+  await page.locator("#login-password").press("Enter");
+  await expect(page.locator("#login-password")).toHaveCount(0);
+}
+
+async function postApi(
+  request: APIRequestContext,
+  endpoint: ApiEndpoint,
+  body: Record<string, unknown>,
+): Promise<ApiReply> {
+  const response = await csrfFetch(request, endpoint, body);
+  const text = await response.text();
+  try {
+    return { status: response.status(), body: JSON.parse(text) };
+  } catch {
+    return { status: response.status(), body: text };
+  }
+}
+
+function describeReply(reply: ApiReply): string {
+  return `HTTP ${reply.status} ${JSON.stringify(reply.body)}`;
+}
+
+function successData(kind: string, type: string, reply: ApiReply): unknown {
+  const parsed = successEnvelope.safeParse(reply.body);
+  const succeeded =
+    reply.status >= 200 &&
+    reply.status < 300 &&
+    parsed.success &&
+    parsed.data.isSuccess !== false &&
+    parsed.data.error === undefined;
+  if (!succeeded) {
+    throw new Error(`Expected ${kind} "${type}" to succeed but got ${describeReply(reply)}`);
+  }
+  return parsed.data.data;
+}
+
+function failureInfo(kind: string, type: string, reply: ApiReply): WriteErrorInfo {
+  const parsed = errorEnvelope.safeParse(reply.body);
+  if (reply.status < 400 || !parsed.success) {
+    throw new Error(`Expected ${kind} "${type}" to fail but got ${describeReply(reply)}`);
+  }
+  // @cast-boundary engine-payload — the wire error envelope is WriteErrorInfo minus httpStatus
+  return { ...(parsed.data.error as Omit<WriteErrorInfo, "httpStatus">), httpStatus: reply.status };
+}
+
+export async function apiWrite<T = Record<string, unknown>>(
+  request: APIRequestContext,
+  type: string,
+  payload: unknown,
+  requestId?: string,
+): Promise<T> {
+  const reply = await postApi(request, "/api/write", { type, payload, requestId });
+  return successData("write", type, reply) as T; // @cast-boundary engine-payload
+}
+
+export async function apiQuery<T = unknown>(
+  request: APIRequestContext,
+  type: string,
+  payload: unknown = {},
+): Promise<T> {
+  const reply = await postApi(request, "/api/query", { type, payload });
+  return successData("query", type, reply) as T; // @cast-boundary engine-payload
+}
+
+export async function apiCommand(
+  request: APIRequestContext,
+  type: string,
+  payload: unknown,
+): Promise<void> {
+  const reply = await postApi(request, "/api/command", { type, payload });
+  if (reply.status !== 202) {
+    throw new Error(
+      `Expected command "${type}" to be accepted (202) but got ${describeReply(reply)}`,
+    );
+  }
+}
+
+export function createHttpApi(request: APIRequestContext): BoundApi {
+  return {
+    writeOk: (type, payload, requestId) => apiWrite(request, type, payload, requestId),
+    writeErr: async (type, payload) =>
+      failureInfo("write", type, await postApi(request, "/api/write", { type, payload })),
+    queryOk: (type, payload) => apiQuery(request, type, payload),
+    queryErr: async (type, payload) =>
+      failureInfo("query", type, await postApi(request, "/api/query", { type, payload })),
+  };
+}
+
+export async function totpCode(secret: Buffer | string, nowMs?: number): Promise<string> {
+  const key =
+    typeof secret === "string"
+      ? (await import("@cosmicdrift/kumiko-bundled-features/auth-mfa")).base32Decode(secret)
+      : secret;
+  return currentTotpCode(key, nowMs);
+}

package/src/e2e/constants.ts

@@ -0,0 +1,27 @@
+export const KUMIKO_SECRETS_MASTER_KEY_V1 = "a3VtaWtvLXNjcmVlbnNob3QtZGV2LW1hc3Rlci0zMmI=";
+
+export const PLAYWRIGHT_DEMO_ENV = {
+  JWT_SECRET: "kumiko-e2e-jwt-secret-min-32-chars-ephemeral",
+  KUMIKO_DEV_DB_NAME: "",
+  KUMIKO_SECRETS_MASTER_KEY_V1,
+  KUMIKO_SECRETS_MASTER_KEY_CURRENT_VERSION: "1",
+} as const;
+
+export const CSRF_COOKIE_NAME = "kumiko_csrf";
+export const CSRF_HEADER_NAME = "X-CSRF-Token";
+
+export const SEED_ENABLE_ENV = "KUMIKO_TEST_SEED";
+export const SEED_TOKEN_ENV = "KUMIKO_TEST_SEED_TOKEN";
+export const SEED_TOKEN_HEADER = "x-kumiko-test-seed";
+export const E2E_WORKERS_ENV = "KUMIKO_E2E_WORKERS";
+
+// Same literal as the framework's requireRealProviders(), which does not export it.
+export const REAL_PROVIDERS_ENV = "KUMIKO_REAL_PROVIDERS";
+
+export const SEED_ROUTE_PREFIX = "/__test";
+
+export const SEED_ROUTES = {
+  seedTenant: `${SEED_ROUTE_PREFIX}/seed-tenant`,
+  seedUser: `${SEED_ROUTE_PREFIX}/seed-user`,
+  inbox: `${SEED_ROUTE_PREFIX}/inbox`,
+} as const;