@cosmicdrift/kumiko-testing 0.387.0 → 0.388.0

package/src/stack/test-stack.ts

@@ -1,9 +1,5 @@
 // @runtime dev
-import { createHash } from "node:crypto";
-import type { AuthRoutesConfig, JwtHelper } from "@cosmicdrift/kumiko-framework/api";
-import { buildServer, createSseBroker, type SseBroker } from "@cosmicdrift/kumiko-framework/api";
-import type { DbConnection, EntityTableMeta } from "@cosmicdrift/kumiko-framework/db";
-import { createRegistry, validateBoot } from "@cosmicdrift/kumiko-framework/engine";
+import type { AuthRoutesConfig, JwtHelper, SseBroker } from "@cosmicdrift/kumiko-framework/api";
 import type {
   AppContext,
   FeatureDefinition,
@@ -12,56 +8,30 @@ import type {
   TenantId,
 } from "@cosmicdrift/kumiko-framework/engine/types";
 import type { ErrorDocsConfig } from "@cosmicdrift/kumiko-framework/errors";
-import {
-  createArchivedStreamsTable,
-  createEventsTable,
-} from "@cosmicdrift/kumiko-framework/event-store";
 import type { Lifecycle } from "@cosmicdrift/kumiko-framework/internal/stack-support";
-import {
-  createRateLimitResolver,
-  unsafePushTables,
-  validateNavBootSubset,
-  validateOwnershipBoot,
-} from "@cosmicdrift/kumiko-framework/internal/stack-support";
-import {
-  createJobRunner,
-  type JobRunner,
-  type JobRunnerOptions,
-} from "@cosmicdrift/kumiko-framework/jobs";
-import {
-  createNoopProvider,
-  type ObservabilityProvider,
-} from "@cosmicdrift/kumiko-framework/observability";
+import type { JobRunner, JobRunnerOptions } from "@cosmicdrift/kumiko-framework/jobs";
+import type { ObservabilityProvider } from "@cosmicdrift/kumiko-framework/observability";
 import type {
   Dispatcher,
   EventDispatcher,
   SystemHooks,
 } from "@cosmicdrift/kumiko-framework/pipeline";
-import {
-  createEntityCache,
-  createEventDedup,
-  createIdempotencyGuard,
-  dispatcherToWriteRef,
-} from "@cosmicdrift/kumiko-framework/pipeline";
-import {
-  type ClosableCacheSyncBus,
-  createLocalCacheSyncBus,
-  createRedisCacheSyncBus,
-} from "@cosmicdrift/kumiko-framework/redis";
+import type { ClosableCacheSyncBus } from "@cosmicdrift/kumiko-framework/redis";
 import type { SearchAdapter } from "@cosmicdrift/kumiko-framework/search";
-import { createInMemorySearchAdapter } from "@cosmicdrift/kumiko-framework/search";
-import { propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
 import type { Hono } from "hono";
+import { createJobFailureTracker } from "./drain-jobs.ts";
+import type { EventCollector } from "./event-collector.ts";
+import type { TestRedis } from "./redis.ts";
+import type { RequestHelper } from "./request-helper.ts";
 import {
-  createTestDb,
-  ensureTestDbTemplate,
-  TEST_DB_TEMPLATE_RUN_ENV,
-  testDbTemplatePrefix,
-} from "./db.ts";
-import { createJobFailureTracker, drainJobs } from "./drain-jobs.ts";
-import { createEventCollector, type EventCollector } from "./event-collector.ts";
-import { createTestRedis, queueNamePrefixForTestRedis, type TestRedis } from "./redis.ts";
-import { createRequestHelper, type RequestHelper } from "./request-helper.ts";
+  buildStackServices,
+  createStackCacheSync,
+  createStackJobRunner,
+  provisionStackStorage,
+  runCleanupsIgnoringErrors,
+  startStackServer,
+  validateStackFeatures,
+} from "./test-stack-setup.ts";
 
 export type TestStack = {
   app: Hono;
@@ -288,295 +258,19 @@ export type TestStackOptions = {
 
 const DEFAULT_JWT_SECRET = "test-stack-secret-minimum-32-characters!!";
 
-type MfaTokenSecretBinder = (
-  masterSecret: string,
-  env: Readonly<Record<string, string | undefined>>,
-) => void;
-
-// Mirrors bindMfaTokenSecretsFromFeature from bundled-features/auth-mfa,
-// which this package cannot import: bundled-features is an optional peer.
-function isMfaTokenSecretBinder(value: unknown): value is MfaTokenSecretBinder {
-  return typeof value === "function";
-}
-
-// The env is empty on purpose: test secrets derive from jwtSecret,
-// independent of the host env.
-function bindMfaTokenSecrets(features: readonly FeatureDefinition[], jwtSecret: string): void {
-  for (const { exports } of features) {
-    if (typeof exports !== "object" || exports === null || !("bindTokenSecrets" in exports)) {
-      continue;
-    }
-    const { bindTokenSecrets } = exports;
-    if (isMfaTokenSecretBinder(bindTokenSecrets)) bindTokenSecrets(jwtSecret, {});
-  }
-}
-
-// Same table list as `kumiko schema generate` (collectTableMetas) — divergence
-// caused a production crash and left r.entity() tables missing.
-async function collectStackTableMetas(
-  options: TestStackOptions,
-): Promise<readonly EntityTableMeta[]> {
-  const { collectTableMetas, enumerateFeatureTableSources, extractTableInfo } = await import(
-    "@cosmicdrift/kumiko-framework/db"
-  );
-  const metas = collectTableMetas(options.features);
-  if (options.entityTables !== false) return metas;
-  const nonEntityNames = new Set(
-    options.features.flatMap((f) =>
-      enumerateFeatureTableSources(f).map((s) => extractTableInfo(s.table).name),
-    ),
-  );
-  return metas.filter((m) => nonEntityNames.has(m.tableName));
-}
-
-async function pushStackSchema(
-  db: DbConnection,
-  metas: readonly EntityTableMeta[],
-  withFileTables: boolean,
-): Promise<void> {
-  // Every ES-entity writes events via createEventStoreExecutor in the
-  // feature's write handlers. Auto-create the events table so every
-  // setupTestStack call is ready for writes without needing a manual
-  // createEventsTable().
-  await createEventsTable(db);
-  // Archive-stream metadata — needed by ctx.appendEvent's archive guard and
-  // loadAggregate's default-skip. Idempotent, so production boot running
-  // the same call is fine.
-  await createArchivedStreamsTable(db);
-
-  // Framework state for projection rebuild/status + event-consumer cursors.
-  // Idempotent — production boot flows run the same calls.
-  const { createProjectionStateTable, createEventConsumerStateTable } = await import(
-    "@cosmicdrift/kumiko-framework/pipeline"
-  );
-  await createProjectionStateTable(db);
-  await createEventConsumerStateTable(db);
-
-  // Files support: when a provider is registered, the fileRefs table must
-  // exist before the first upload. Skipped when no provider — the table
-  // stays off tenant test DBs that never touch files.
-  if (withFileTables) {
-    const { fileRefsTable, fileUploadLedgerTable } = await import(
-      "@cosmicdrift/kumiko-framework/files"
-    );
-    await unsafePushTables(db, { fileRefsTable, fileUploadLedgerTable });
-  }
-
-  const { tableExists } = await import("@cosmicdrift/kumiko-framework/db");
-  const missing: Record<string, unknown> = {};
-  for (const meta of metas) {
-    if (await tableExists(db, `public.${meta.tableName}`)) continue;
-    missing[meta.tableName] = meta;
-  }
-  if (Object.keys(missing).length > 0) {
-    await unsafePushTables(db, missing);
-  }
-}
-
-// Only inside an integration-runner run: the framework tables above are not part
-// of the fingerprint, which holds because one run never sees two framework versions.
-async function resolveTestDbTemplateName(
-  options: TestStackOptions,
-  metas: readonly EntityTableMeta[],
-  withFileTables: boolean,
-): Promise<string | undefined> {
-  const runId = process.env[TEST_DB_TEMPLATE_RUN_ENV];
-  if (runId === undefined || options.persistentDb === true || options.dbName !== undefined) {
-    return undefined;
-  }
-  const { renderTablesDdl } = await import("@cosmicdrift/kumiko-framework/db");
-  const fingerprint = createHash("sha256")
-    .update(JSON.stringify({ withFileTables, ddl: renderTablesDdl(metas) }))
-    .digest("hex")
-    .slice(0, 16);
-  return `${testDbTemplatePrefix(runId)}${fingerprint}`;
-}
-
 export async function setupTestStack(options: TestStackOptions): Promise<TestStack> {
   const jwtSecret = options.jwtSecret ?? DEFAULT_JWT_SECRET;
   const enabledHooks = options.systemHooks ?? ["sse", "search"];
-
-  // Install the Temporal polyfill before feature code runs. Idempotent: the
-  // production server boot does the same. A no-op on runtimes with native Temporal.
-  const { ensureTemporalPolyfill } = await import("@cosmicdrift/kumiko-framework/time");
-  await ensureTemporalPolyfill();
-
-  // Ownership boot-guards (unqualified where-fragments, where-rules on the
-  // write path) otherwise run only in the prod boot via validateBoot, leaving
-  // every test stack blind to a broken access map.
-  // Runs after the polyfill (buildEntityTable needs it to derive the probe
-  // columns) and before the ephemeral DB/Redis exist, so a throw can't leak
-  // a database that nothing will clean up.
-  validateOwnershipBoot(options.features);
-  // Nav/workspace refs fail the prod boot too; the subset check tolerates refs into unmounted features.
-  validateNavBootSubset(options.features);
-  if (options.validateBoot === "full") validateBoot(options.features);
-  bindMfaTokenSecrets(options.features, jwtSecret);
-
-  const stackTableMetas = await collectStackTableMetas(options);
-  const withFileTables = options.files !== undefined;
-  const buildStackSchema = (db: DbConnection): Promise<void> =>
-    pushStackSchema(db, stackTableMetas, withFileTables);
-  const templateDbName = await resolveTestDbTemplateName(options, stackTableMetas, withFileTables);
-  if (templateDbName !== undefined) await ensureTestDbTemplate(templateDbName, buildStackSchema);
-
-  // Forward db-name/persistent-flag through to createTestDb. The
-  // defaults (undefined dbName, persistent:false) keep the legacy
-  // test contract: fresh kumiko_test_<random> DB per setup, dropped
-  // on cleanup.
-  const [testDb, testRedis] = await Promise.all([
-    createTestDb({
-      ...(options.dbName !== undefined && { dbName: options.dbName }),
-      ...(options.persistentDb !== undefined && { persistent: options.persistentDb }),
-      ...(options.dbPoolMax !== undefined && { poolMax: options.dbPoolMax }),
-      ...(options.outsideTransactionPoolMax !== undefined && {
-        outsideTransactionPoolMax: options.outsideTransactionPoolMax,
-      }),
-      ...(templateDbName !== undefined && { templateDbName }),
-    }),
-    createTestRedis(
-      options.sharedRedisWith && { borrowKeyPrefix: options.sharedRedisWith.redis.keyPrefix },
-    ),
-  ]);
-
-  // Any throw in this DDL region must still drop the just-created ephemeral
-  // DB/Redis — the caller never gets the stack object back to call
-  // cleanup() itself (same "leaked ephemeral DB" failure class as the later
-  // try/catch below, but for setup that runs before that try starts).
-  if (templateDbName === undefined) {
-    try {
-      await buildStackSchema(testDb.db);
-    } catch (error) {
-      try {
-        await testDb.cleanup();
-      } catch {
-        // ignore — `error` is the one that matters
-      }
-      try {
-        await testRedis.cleanup();
-      } catch {
-        // ignore — `error` is the one that matters
-      }
-      throw error;
-    }
-  }
-
-  // Redis only where two stacks can actually disagree (avoids two extra
-  // Pub/Sub connections); otherwise a local bus so invalidation still works
-  // inside this stack. Passing it explicitly keeps buildServer from using its
-  // REDIS_URL default (an unnamespaced channel).
-  const cacheSync: ClosableCacheSyncBus =
-    options.cacheSync || options.sharedRedisWith
-      ? createRedisCacheSyncBus({
-          redisUrl: testRedis.redisUrl,
-          channelPrefix: testRedis.keyPrefix,
-        })
-      : createLocalCacheSyncBus();
-
-  const searchAdapter = createInMemorySearchAdapter();
-  const events = createEventCollector();
-  const registry = createRegistry([...options.features]);
-
-  // Wire SSE broker with event collector — built early (not just before
-  // buildServer) because extraContext + the job context below both need it.
-  const sseBroker = createSseBroker();
-  sseBroker.addClient(
-    "tenant:00000000-0000-4000-8000-000000000001",
-    (event) => events.sse.push(event),
-    () => {},
-  );
-
-  const entityCache = createEntityCache(testRedis.redis, { ttlSeconds: 60 });
-
-  // A static `files.storageProvider` is wired as the per-tenant resolver — the
-  // framework test seam that doesn't require mounting config + file-foundation.
-  // (Bundled GDPR tests mount the real provider features instead.)
-  let fileProviderResolver:
-    | import("@cosmicdrift/kumiko-framework/files").FileProviderResolver
-    | undefined;
-  if (options.files) {
-    const provider = options.files.storageProvider;
-    const { withUploadLedger } = await import("@cosmicdrift/kumiko-framework/files");
-    fileProviderResolver = withUploadLedger(() => Promise.resolve(provider), testDb.db);
-  }
-
-  const observability = options.observability ?? createNoopProvider();
-
-  // Same AppContext buildServer() gets below (db/redis/searchAdapter/
-  // entityCache/masterKeyProvider/fileProviderResolver/extraContext) —
-  // shared so the job context can't drift from the request-path context:
-  // a reduced `{ db, registry }` literal let jobs pass in tests while
-  // reaching for fields only prod's context has.
-  //
-  // effectiveFeatures deliberately stays OUT of appContext — prod never puts
-  // it there either (only dispatcherOptions.effectiveFeatures, consumed by
-  // the command-dispatcher — see buildJobRunnerWithHook in entrypoint/
-  // index.ts). Putting it here would reintroduce the exact test-vs-prod
-  // drift fixed: a job/handler reading `ctx.effectiveFeatures` would pass in
-  // tests and break in prod.
-  const appContext = {
-    db: testDb.db,
-    redis: testRedis.redis,
-    searchAdapter,
-    entityCache,
-    registry,
-    ...(options.masterKeyProvider ? { masterKeyProvider: options.masterKeyProvider } : {}),
-    ...(fileProviderResolver ? { _fileProviderResolver: fileProviderResolver } : {}),
-    ...(options.defaultLocale !== undefined && { defaultLocale: options.defaultLocale }),
-    ...(typeof options.extraContext === "function"
-      ? options.extraContext({ registry, db: testDb.db, sseBroker, redis: testRedis.redis })
-      : options.extraContext),
-  };
-
-  // Built before buildServer() so it can be merged into dispatcherOptions
-  // (write handlers' `ctx.jobRunner.dispatch(...)` and the afterCommit
-  // event-trigger hook both need it present at dispatcher-construction
-  // time, same as the prod entrypoint's buildJobRunnerWithHook). Uses the
-  // test-stack's own ephemeral redis — no separate `redisUrl` seam needed.
-  //
-  // context = appContext + tracer/meter, mirroring the prod entrypoint's
-  // `contextWithObservability(options.context, observability)`.
-  let jobRunner: JobRunner | undefined;
-  // Fed to createJobRunner's onJobComplete/onJobFailed below so drainJobs()
+  await validateStackFeatures(options, jwtSecret);
+  const { testDb, testRedis } = await provisionStackStorage(options);
+  const cacheSync = createStackCacheSync(options, testRedis);
+  const services = await buildStackServices(options, testDb, testRedis);
+  // Fed to the job runner's onJobComplete/onJobFailed so drainJobs()
   // can tell a job's final outcome apart from an attempt that will retry —
-  // built before createJobRunner regardless of whether a runner ends up
-  // existing, so the returned drainJobs() closure always has one to read.
+  // built regardless of whether a runner ends up existing, so the returned
+  // drainJobs() closure always has one to read.
   const jobFailureTracker = createJobFailureTracker();
-  if (options.jobs && registry.getAllJobs().size > 0) {
-    const runLogger = options.jobs.runLogger?.({ registry, db: testDb.db });
-    jobRunner = createJobRunner({
-      registry,
-      context: { ...appContext, tracer: observability.tracer, meter: observability.meter },
-      // The real REDIS_URL, not one rebuilt from `.options` — rebuilding it lost
-      // password/username/tls/path.
-      redisUrl: testRedis.redisUrl,
-      ...(options.jobs.consumerLane !== undefined && { consumerLane: options.jobs.consumerLane }),
-      queueNamePrefix:
-        options.jobs.queueNamePrefix ?? queueNamePrefixForTestRedis(testRedis.keyPrefix),
-      ...(options.jobs.getActiveTenantIds !== undefined && {
-        getActiveTenantIds: options.jobs.getActiveTenantIds,
-      }),
-      ...(runLogger?.onJobStart !== undefined && { onJobStart: runLogger.onJobStart }),
-      ...(runLogger?.onJobQueued !== undefined && { onJobQueued: runLogger.onJobQueued }),
-      ...(runLogger?.onJobDropped !== undefined && { onJobDropped: runLogger.onJobDropped }),
-      // Tracker fires in finally: drainJobs wakes on it, so the log row must
-      // be written first, and a throwing logger must not swallow the signal.
-      onJobComplete: async (jobName, jobId, ...rest) => {
-        try {
-          await runLogger?.onJobComplete?.(jobName, jobId, ...rest);
-        } finally {
-          jobFailureTracker.onJobComplete(jobName, jobId);
-        }
-      },
-      onJobFailed: async (jobName, jobId, error, ...rest) => {
-        try {
-          await runLogger?.onJobFailed?.(jobName, jobId, error, ...rest);
-        } finally {
-          jobFailureTracker.onJobFailed(jobName, jobId, error);
-        }
-      },
-    });
-  }
+  const jobRunner = createStackJobRunner(options, services, testDb, testRedis, jobFailureTracker);
 
   // From here on, any throw must stop a jobRunner that was already created
   // above (createJobRunner() itself opens live BullMQ Queue/lock Redis
@@ -584,180 +278,17 @@ export async function setupTestStack(options: TestStackOptions): Promise<TestSta
   // buildServer()/search-config/etc. leaks that connection and the test
   // process hangs on exit.
   try {
-    if (jobRunner) await jobRunner.start();
-
-    // Auto-configure search for tenant 1 based on registry
-    if (enabledHooks.includes("search")) {
-      const searchableFields: string[] = [];
-      for (const feature of options.features) {
-        for (const [, entity] of Object.entries(feature.entities ?? {})) {
-          for (const [fieldName, field] of Object.entries(entity.fields)) {
-            if (field.type === "text" && field.searchable) {
-              searchableFields.push(fieldName);
-            }
-            if (field.type === "embedded") {
-              for (const [subName, subField] of Object.entries(field.schema)) {
-                if (subField.searchable) {
-                  searchableFields.push(`${fieldName}_${subName}`);
-                }
-              }
-            }
-          }
-        }
-      }
-
-      if (options.searchConfig) {
-        await searchAdapter.configure(options.searchConfig.tenantId, {
-          searchableFields: options.searchConfig.searchableFields,
-          rankingFields: options.searchConfig.rankingFields,
-        });
-      } else if (searchableFields.length > 0) {
-        await searchAdapter.configure("00000000-0000-4000-8000-000000000001", {
-          searchableFields,
-          rankingFields: searchableFields,
-        });
-      }
-    }
-
-    const idempotency = createIdempotencyGuard(testRedis.redis, { ttlSeconds: 60 });
-    const eventDedup = createEventDedup(testRedis.redis, { ttlSeconds: 60 });
-
-    // buildServer only auto-wires an L3 RateLimitResolver from
-    // `context.redis` — a degradation test that nulls `redis` via
-    // extraContext (to exercise a handler's own ctx.redis-down guard) also
-    // silently strips rate-limiting, even though every handler with a
-    // `rateLimit` declaration still requires a resolver at dispatch time.
-    // Since e7bf543ad, an IP-keyed bucket key is built unconditionally
-    // (falls back to a shared "unknown" IP rather than skipping), so the
-    // missing resolver now throws instead of merely skipping enforcement.
-    // Mirrors idempotency/eventDedup above: built from the test-stack's own
-    // always-real `testRedis.redis`, independent of whatever extraContext
-    // did to `appContext.redis` — an explicit `context.rateLimit` from
-    // extraContext still wins (same precedence buildServer documents).
-    const explicitRateLimit = propertyOf(appContext, "rateLimit");
-    const needsOwnRateLimitResolver =
-      explicitRateLimit === undefined &&
-      (appContext.redis === undefined || options.rateLimitNowMs !== undefined);
-    const rateLimitFallback = needsOwnRateLimitResolver
-      ? createRateLimitResolver({
-          // An app-supplied redis keeps buckets and app redis on the same instance.
-          redis: appContext.redis ?? testRedis.redis,
-          ...(options.rateLimitNowMs ? { nowMs: options.rateLimitNowMs } : {}),
-        })
-      : undefined;
-
-    const server = buildServer({
-      registry,
-      context: rateLimitFallback ? { ...appContext, rateLimit: rateLimitFallback } : appContext,
+    return await startStackServer({
+      options,
       jwtSecret,
-      ...(options.observability ? { observability: options.observability } : {}),
-      ...(options.lifecycleSystemHooks && { systemHooks: options.lifecycleSystemHooks }),
-      dispatcherOptions: {
-        idempotency,
-        cacheSync,
-        outsideTransactionDb: testDb.outsideTransactionDb,
-        ...(options.effectiveFeatures && { effectiveFeatures: options.effectiveFeatures }),
-        ...(jobRunner && { jobRunner }),
-      },
-      eventDedup,
-      sseBroker,
-      ...(options.trustedProxyHops !== undefined && { trustedProxyHops: options.trustedProxyHops }),
-      ...(options.errorDocs && { errorDocs: options.errorDocs }),
-      ...(options.extraRoutes && { extraRoutes: options.extraRoutes }),
-      ...(options.metrics && { metrics: options.metrics }),
-      // Tests drive the dispatcher via stack.eventDispatcher.runOnce() for
-      // deterministic drains — no timer-induced flakiness. pollIntervalMs
-      // stays short anyway in case a test opts into `.start()`. pgClient
-      // plumbs through the LISTEN wake-up for tests that want to measure
-      // post-commit latency (Sprint E.4).
-      eventDispatcher: {
-        pollIntervalMs: options.eventDispatcherPollIntervalMs ?? 50,
-        pgClient: testDb.client,
-        systemConsumers: {
-          sse: enabledHooks.includes("sse"),
-          search: enabledHooks.includes("search"),
-          accessInvalidation: enabledHooks.includes("sse"),
-        },
-      },
-      // Default tests to no login rate-limiter so existing suites that loop
-      // over logins don't hit a 429 after 10 attempts. Suites specifically
-      // testing the limiter can override via authConfig.loginRateLimit.
-      ...(options.authConfig
-        ? {
-            auth: {
-              ...options.authConfig,
-              ...(options.authConfig.loginRateLimit === undefined ? { loginRateLimit: null } : {}),
-            },
-          }
-        : {}),
-      ...(options.lifecycle ? { lifecycle: options.lifecycle } : {}),
-      ...(options.rateLimit ? { rateLimit: options.rateLimit } : {}),
-      ...(await (async () => {
-        const baseAnon =
-          typeof options.anonymousAccess === "function"
-            ? options.anonymousAccess({
-                registry,
-                db: testDb.db,
-                sseBroker,
-                redis: testRedis.redis,
-              })
-            : options.anonymousAccess;
-        const resolvedAnon = options.enrichAnonymousAccess
-          ? await options.enrichAnonymousAccess(baseAnon, {
-              registry,
-              db: testDb.db,
-            })
-          : baseAnon;
-        return resolvedAnon ? { anonymousAccess: resolvedAnon } : {};
-      })()),
-    });
-
-    // Mirrors the prod entrypoints — without this, JobContext.write/writeAs/
-    // queryAs/queryAsMember throw on first use inside a test-stack job.
-    if (jobRunner) jobRunner.attachDispatcher(dispatcherToWriteRef(server.dispatcher));
-
-    const eventDispatcher: EventDispatcher | undefined = server.eventDispatcher;
-
-    // Pre-register consumer state rows so tests can call runOnce() directly
-    // without a preceding explicit start(). Timer fires at pollIntervalMs=50
-    // but each consumer runs at most one turn at a time — tests that drain via
-    // runOnce() remain deterministic. Tests that specifically exercise the
-    // timer loop call start() again (idempotent) after setup.
-    if (eventDispatcher) await eventDispatcher.ensureRegistered();
-
-    const http = createRequestHelper(server.app, server.jwt, {
-      ...(options.authConfig?.sessionCreator !== undefined && {
-        sessionCreator: options.authConfig.sessionCreator,
-      }),
-    });
-
-    return {
-      app: server.app,
-      jwt: server.jwt,
-      registry,
-      db: testDb.db,
-      dbPoolMax: testDb.poolMax,
-      redis: testRedis,
+      enabledHooks,
+      testDb,
+      testRedis,
       cacheSync,
-      search: searchAdapter,
-      events,
-      http,
-      observability: server.observability,
-      sseBroker,
-      dispatcher: server.dispatcher,
-      context: server.context,
-      ...(eventDispatcher ? { eventDispatcher } : {}),
-      ...(server.lifecycle ? { lifecycle: server.lifecycle } : {}),
-      ...(jobRunner ? { jobRunner } : {}),
-      drainJobs: () => drainJobs({ db: testDb.db, eventDispatcher, jobRunner }, jobFailureTracker),
-      cleanup: async () => {
-        if (jobRunner) await jobRunner.stop();
-        if (eventDispatcher) await eventDispatcher.stop();
-        await server.observability.shutdown();
-        await cacheSync.close();
-        await Promise.all([testDb.cleanup(), testRedis.cleanup()]);
-      },
-    };
+      services,
+      jobRunner,
+      jobFailureTracker,
+    });
   } catch (error) {
     // Best-effort — a broken jobRunner.stop()/cleanup() must never mask the
     // real setup failure below. testDb/testRedis are created before this
@@ -766,28 +297,14 @@ export async function setupTestStack(options: TestStackOptions): Promise<TestSta
     // sockets — the caller never gets the stack object back to call
     // cleanup() itself, which is the same "hangs on exit" failure class
     // this function exists to prevent.
-    if (jobRunner) {
-      try {
-        await jobRunner.stop();
-      } catch {
-        // ignore — `error` is the one that matters
-      }
-    }
-    try {
-      await cacheSync.close();
-    } catch {
-      // ignore — `error` is the one that matters
-    }
-    try {
-      await testDb.cleanup();
-    } catch {
-      // ignore — `error` is the one that matters
-    }
-    try {
-      await testRedis.cleanup();
-    } catch {
-      // ignore — `error` is the one that matters
-    }
+    await runCleanupsIgnoringErrors([
+      async () => {
+        if (jobRunner) await jobRunner.stop();
+      },
+      () => cacheSync.close(),
+      () => testDb.cleanup(),
+      () => testRedis.cleanup(),
+    ]);
     throw error;
   }
 }