@stigmer/server 3.14.0-dev.20260910084630

package/src/transport/__tests__/demux.test.ts

@@ -0,0 +1,213 @@
+/**
+ * Spike SP-A (D2 spike register): the cleartext preface demux serves all
+ * four verified client transports on ONE port. These tests pin the demux
+ * against the exact transport constructors the real clients use:
+ *
+ *   1. native gRPC over h2c        — runner (stigmer-client.ts) and the
+ *                                    conformance harness (harness/clients.ts)
+ *   2. gRPC-Web over HTTP/1.1      — browser SDK (sdk/typescript/transport.ts)
+ *   3. Connect over HTTP/1.1       — SDK `transport: "connect"` (additive
+ *                                    delta 2, ratified 2026-08-22)
+ *   4. Connect over HTTP/2         — same protocol on the h2 path
+ *
+ * Plus the two socket shapes that must never wedge the port: the CLI
+ * readiness gate's bare TCP probe (connect + close, no bytes) and a
+ * byte-fragmented preface (TCP permits 24 bytes in two segments).
+ *
+ * A failure here is a protocol surprise (collaboration protocol): the
+ * fallback ladder in D2's spike register is an OWNER decision.
+ */
+import { createClient, type Transport } from "@connectrpc/connect";
+import {
+  createConnectTransport,
+  createGrpcTransport,
+  createGrpcWebTransport,
+} from "@connectrpc/connect-node";
+import { connectNodeAdapter } from "@connectrpc/connect-node";
+import {
+  Health,
+  HealthCheckResponse_ServingStatus,
+} from "@stigmer/protos/grpc/health/v1/health_pb";
+import { createServer as createHttp1Server } from "node:http";
+import { createServer as createHttp2Server } from "node:http2";
+import { connect as netConnect, type Server, type Socket } from "node:net";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import {
+  createProtocolDemuxServer,
+  HTTP2_CONNECTION_PREFACE,
+} from "../demux.js";
+
+let demux: Server;
+let baseUrl: string;
+let port: number;
+// gRPC clients hold their h2 sessions open, so a bare server.close() would
+// wait forever; teardown destroys whatever the tests left connected.
+const liveSockets = new Set<Socket>();
+
+beforeAll(async () => {
+  const handler = connectNodeAdapter({
+    routes: (router) => {
+      router.service(Health, {
+        check: () => ({ status: HealthCheckResponse_ServingStatus.SERVING }),
+        list: () => ({ statuses: {} }),
+        // The spike never calls watch; an empty stream satisfies the type.
+        watch: async function* () {},
+      });
+    },
+  });
+
+  demux = createProtocolDemuxServer({
+    http1: createHttp1Server(handler),
+    http2: createHttp2Server(handler),
+  });
+
+  demux.on("connection", (socket: Socket) => {
+    liveSockets.add(socket);
+    socket.on("close", () => liveSockets.delete(socket));
+  });
+
+  port = await new Promise<number>((resolve, reject) => {
+    demux.once("error", reject);
+    demux.listen(0, "127.0.0.1", () => {
+      const address = demux.address();
+      if (address === null || typeof address === "string") {
+        reject(new Error("demux bound without a TCP address"));
+        return;
+      }
+      resolve(address.port);
+    });
+  });
+  baseUrl = `http://127.0.0.1:${port}`;
+});
+
+afterAll(async () => {
+  const closed = new Promise<void>((resolve) => demux.close(() => resolve()));
+  for (const socket of liveSockets) {
+    socket.destroy();
+  }
+  await closed;
+});
+
+async function checkHealth(
+  transport: Transport,
+): Promise<HealthCheckResponse_ServingStatus> {
+  const client = createClient(Health, transport);
+  const response = await client.check({});
+  return response.status;
+}
+
+describe("SP-A: the preface demux serves all four verified client transports", () => {
+  it("serves native gRPC over h2c (runner / conformance harness shape)", async () => {
+    const status = await checkHealth(createGrpcTransport({ baseUrl }));
+    expect(status).toBe(HealthCheckResponse_ServingStatus.SERVING);
+  });
+
+  it("serves gRPC-Web over HTTP/1.1 (browser SDK shape)", async () => {
+    const status = await checkHealth(
+      createGrpcWebTransport({ baseUrl, httpVersion: "1.1" }),
+    );
+    expect(status).toBe(HealthCheckResponse_ServingStatus.SERVING);
+  });
+
+  it("serves the Connect protocol over HTTP/1.1 (SDK connect option)", async () => {
+    const status = await checkHealth(
+      createConnectTransport({ baseUrl, httpVersion: "1.1" }),
+    );
+    expect(status).toBe(HealthCheckResponse_ServingStatus.SERVING);
+  });
+
+  it("serves the Connect protocol over HTTP/2", async () => {
+    const status = await checkHealth(
+      createConnectTransport({ baseUrl, httpVersion: "2" }),
+    );
+    expect(status).toBe(HealthCheckResponse_ServingStatus.SERVING);
+  });
+});
+
+describe("SP-A: socket shapes that must not wedge the port", () => {
+  it("survives the CLI readiness gate's bare TCP probe (connect, no bytes, close)", async () => {
+    await new Promise<void>((resolve, reject) => {
+      const probe = netConnect(port, "127.0.0.1", () => {
+        probe.end();
+      });
+      probe.on("close", () => resolve());
+      probe.on("error", reject);
+    });
+
+    // The port still serves after the probe: the exact sequence the daemon
+    // performs on every boot (probe, then real gRPC traffic).
+    const status = await checkHealth(createGrpcTransport({ baseUrl }));
+    expect(status).toBe(HealthCheckResponse_ServingStatus.SERVING);
+  });
+
+  it("routes a byte-fragmented HTTP/2 preface to the h2 server", async () => {
+    // Deliver the preface in two TCP segments with a flush gap; the demux
+    // must keep peeking across segments rather than misrouting a strict
+    // preface prefix to HTTP/1.1.
+    //
+    // The assertion demands a PING ACK — not merely a SETTINGS frame. An h2
+    // server emits its SETTINGS before parsing the client preface (spike
+    // SP-A observed exactly that on a session that then died on "bad client
+    // magic"), so SETTINGS proves nothing about the replay path. A PING is
+    // only acknowledged by a session that accepted the preface and is
+    // processing client frames.
+    const socket = netConnect(port, "127.0.0.1");
+    await new Promise<void>((resolve, reject) => {
+      socket.once("connect", () => resolve());
+      socket.once("error", reject);
+    });
+
+    socket.write(HTTP2_CONNECTION_PREFACE.subarray(0, 10));
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    socket.write(HTTP2_CONNECTION_PREFACE.subarray(10));
+    // Client SETTINGS (empty) — required before other frames — then PING.
+    socket.write(
+      Buffer.from([0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00]),
+    );
+    const pingPayload = Buffer.from("spike-a!", "latin1");
+    socket.write(
+      Buffer.concat([
+        Buffer.from([0x00, 0x00, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00]),
+        pingPayload,
+      ]),
+    );
+
+    const sawPingAck = await new Promise<boolean>((resolve, reject) => {
+      let received = Buffer.alloc(0);
+      const timer = setTimeout(
+        () => reject(new Error("no PING ACK from the h2 server within 5s")),
+        5_000,
+      );
+      socket.on("data", (chunk) => {
+        received = Buffer.concat([received, chunk]);
+        // Walk complete 9-byte-header frames looking for PING (0x6) + ACK (0x1).
+        let offset = 0;
+        while (received.length - offset >= 9) {
+          const length = received.readUIntBE(offset, 3);
+          const type = received[offset + 3];
+          const flags = received[offset + 4];
+          if (received.length - offset < 9 + length) {
+            break;
+          }
+          if (type === 0x6 && (flags & 0x1) === 0x1) {
+            clearTimeout(timer);
+            resolve(true);
+            return;
+          }
+          offset += 9 + length;
+        }
+      });
+      socket.on("error", (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+    socket.destroy();
+
+    expect(
+      sawPingAck,
+      "h2 session accepted the replayed preface and ACKed the ping",
+    ).toBe(true);
+  });
+});

package/src/transport/__tests__/server.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Unified-port lane router smoke tests, pinned to the Go router's verified
+ * behavior (pkg/server/server.go:812-836) and the CW-10 suite's assertions:
+ *
+ *   - lane priority: exact registry paths win over everything;
+ *   - unknown paths (incl. unknown /v1/proxy/*) reach the adapter's 404;
+ *   - RPC-lane preflights answer for ANY path, registered or not, in
+ *     rs/cors v1.7 shape (origin echo, method/headers echo, max-age 600);
+ *   - actual cross-origin RPC responses carry the echoed-origin headers;
+ *   - the skill-transfer prefix is a seam: with no handler installed it
+ *     falls through to 404 exactly like an unknown path;
+ *   - shutdown drains promptly with idle keepalive clients connected.
+ *
+ * This suite boots WITHOUT a console lane, so its arms also pin the
+ * lane-absent posture (no bundled export → the router behaves exactly as
+ * before lane 4 existed). The with-console behavior — including the guard
+ * that keeps RPC and /v1/* flowing to the adapter — is pinned in
+ * console/__tests__/handler.test.ts through this same composed server.
+ */
+import { createClient } from "@connectrpc/connect";
+import { createGrpcTransport } from "@connectrpc/connect-node";
+import {
+  Health,
+  HealthCheckResponse_ServingStatus as ServingStatus,
+} from "@stigmer/protos/grpc/health/v1/health_pb";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import { createLogger } from "../../boot/logger.js";
+import { HealthState, registerHealthService } from "../health.js";
+import { createUnifiedPortServer, type UnifiedPortServer } from "../server.js";
+
+const silentLogger = createLogger({
+  level: "error",
+  pretty: false,
+  write: () => {},
+});
+
+let server: UnifiedPortServer;
+let baseUrl: string;
+let healthState: HealthState;
+
+beforeAll(async () => {
+  healthState = new HealthState();
+  server = createUnifiedPortServer({
+    logger: silentLogger,
+    routes: (router) => registerHealthService(router, healthState),
+    interceptors: [],
+    taskKindRegistryLane: (_request, response) => {
+      response.setHeader("x-lane", "task-kind");
+      response.end("{}");
+    },
+    modelRegistryLane: (_request, response) => {
+      response.setHeader("x-lane", "model");
+      response.end("{}");
+    },
+  });
+  const port = await server.listen(0, "127.0.0.1");
+  baseUrl = `http://127.0.0.1:${port}`;
+});
+
+afterAll(async () => {
+  await server.shutdown();
+});
+
+describe("lane priority", () => {
+  it("routes the exact registry paths to their lanes", async () => {
+    const taskKind = await fetch(`${baseUrl}/v1/proxy/task-kind-registry`);
+    expect(taskKind.headers.get("x-lane")).toBe("task-kind");
+    const model = await fetch(`${baseUrl}/v1/proxy/model-registry`);
+    expect(model.headers.get("x-lane")).toBe("model");
+  });
+
+  it("answers 404 for unknown /v1/proxy/* paths (CW-10 fallthrough contract)", async () => {
+    const response = await fetch(`${baseUrl}/v1/proxy/does-not-exist`);
+    expect(response.status).toBe(404);
+  });
+
+  it("answers 404 for the skill-transfer prefix while the seam is empty", async () => {
+    const response = await fetch(`${baseUrl}/v1/skill-artifacts/some-key`, {
+      method: "GET",
+    });
+    expect(response.status).toBe(404);
+  });
+
+  it("answers 404 for arbitrary unknown paths", async () => {
+    const response = await fetch(`${baseUrl}/definitely/not/a/route`);
+    expect(response.status).toBe(404);
+  });
+});
+
+describe("RPC-lane CORS (rs/cors v1.7 shape, allow-all)", () => {
+  it("answers preflights for unregistered endpoints (Go's WithCorsForRegisteredEndpointsOnly(false))", async () => {
+    const response = await fetch(`${baseUrl}/any.Service/AnyMethod`, {
+      method: "OPTIONS",
+      headers: {
+        Origin: "http://localhost:3000",
+        "Access-Control-Request-Method": "POST",
+        "Access-Control-Request-Headers": "content-type,x-grpc-web",
+      },
+    });
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("access-control-allow-origin")).toBe(
+      "http://localhost:3000",
+    );
+    expect(response.headers.get("access-control-allow-credentials")).toBe(
+      "true",
+    );
+    expect(response.headers.get("access-control-allow-methods")).toBe("POST");
+    expect(response.headers.get("access-control-allow-headers")).toBe(
+      "content-type,x-grpc-web",
+    );
+    expect(response.headers.get("access-control-max-age")).toBe("600");
+  });
+
+  it("stamps echoed-origin headers on actual cross-origin RPC responses", async () => {
+    const response = await fetch(`${baseUrl}/grpc.health.v1.Health/Check`, {
+      method: "POST",
+      headers: {
+        Origin: "http://localhost:3000",
+        "Content-Type": "application/json",
+      },
+      body: "{}",
+    });
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("access-control-allow-origin")).toBe(
+      "http://localhost:3000",
+    );
+    expect(response.headers.get("access-control-allow-credentials")).toBe(
+      "true",
+    );
+  });
+});
+
+describe("RPC surface", () => {
+  it("serves the health service through the adapter over native gRPC", async () => {
+    const client = createClient(Health, createGrpcTransport({ baseUrl }));
+    const before = await client.check({});
+    expect(before.status).toBe(ServingStatus.NOT_SERVING);
+
+    healthState.setOverall(ServingStatus.SERVING);
+    const after = await client.check({});
+    expect(after.status).toBe(ServingStatus.SERVING);
+  });
+});

package/src/transport/console/__tests__/handler.test.ts

@@ -0,0 +1,281 @@
+/**
+ * Console lane HTTP contract, proven through the real unified-port server
+ * against a fixture export in a temp directory:
+ *
+ *   - documents, flight payloads, redirects, and the 404 posture arrive
+ *     with the right status, Content-Type, and Cache-Control;
+ *   - /config.json is synthesized per request with a Host-derived apiUrl;
+ *   - the guard: RPC (POST and service-shaped GET), /v1/* paths, and
+ *     OPTIONS preflights flow exactly as they do WITHOUT the lane — the
+ *     wire-invisibility half of the P3 acceptance;
+ *   - both protocol stacks serve the lane (the demux routes browsers to
+ *     HTTP/1.1, but HTTP/2 clients share the same lane router);
+ *   - asset discovery models "not bundled" as absence, not an error.
+ */
+import { createClient } from "@connectrpc/connect";
+import { createGrpcTransport } from "@connectrpc/connect-node";
+import {
+  Health,
+  HealthCheckResponse_ServingStatus as ServingStatus,
+} from "@stigmer/protos/grpc/health/v1/health_pb";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { connect as http2Connect } from "node:http2";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import { createLogger } from "../../../boot/logger.js";
+import { HealthState, registerHealthService } from "../../health.js";
+import {
+  createUnifiedPortServer,
+  type UnifiedPortServer,
+} from "../../server.js";
+import { resolveConsoleAssets } from "../assets.js";
+import { createConsoleLane } from "../handler.js";
+
+const silentLogger = createLogger({
+  level: "error",
+  pretty: false,
+  write: () => {},
+});
+
+/** The fixture export: path → content. Mirrors client-apps/web/out's shape. */
+const FIXTURE_FILES: Record<string, string> = {
+  "index.html": "<html>app shell</html>",
+  "404.html": "<html>not found page</html>",
+  "embed.js": "// embed loader",
+  "conversations.html": "<html>conversations</html>",
+  "conversations.txt": "flight:conversations",
+  "sessions/__placeholder__.html": "<html>session detail</html>",
+  "sessions/__placeholder__.txt": "flight:session",
+  "sessions/__placeholder__/__next.sessions.txt": "flight:nested-session",
+  "_next/static/chunks/app-1a2b3c.js": "// hashed chunk",
+};
+
+let fixtureRoot: string;
+let server: UnifiedPortServer;
+let port: number;
+let baseUrl: string;
+
+beforeAll(async () => {
+  fixtureRoot = mkdtempSync(path.join(tmpdir(), "console-lane-fixture-"));
+  for (const [file, content] of Object.entries(FIXTURE_FILES)) {
+    const target = path.join(fixtureRoot, ...file.split("/"));
+    mkdirSync(path.dirname(target), { recursive: true });
+    writeFileSync(target, content);
+  }
+
+  const assets = resolveConsoleAssets(fixtureRoot, silentLogger);
+  if (assets === undefined) {
+    throw new Error("fixture export was not discovered");
+  }
+  const healthState = new HealthState();
+  healthState.setOverall(ServingStatus.SERVING);
+  server = createUnifiedPortServer({
+    logger: silentLogger,
+    routes: (router) => registerHealthService(router, healthState),
+    interceptors: [],
+    taskKindRegistryLane: (_request, response) => {
+      response.setHeader("x-lane", "task-kind");
+      response.end("{}");
+    },
+    modelRegistryLane: (_request, response) => {
+      response.setHeader("x-lane", "model");
+      response.end("{}");
+    },
+    consoleLane: createConsoleLane({
+      assets,
+      grpcPort: 7234,
+      logger: silentLogger,
+    }),
+  });
+  port = await server.listen(0, "127.0.0.1");
+  baseUrl = `http://127.0.0.1:${port}`;
+});
+
+afterAll(async () => {
+  await server.shutdown();
+  rmSync(fixtureRoot, { recursive: true, force: true });
+});
+
+describe("document serving", () => {
+  it("serves the root document with the app shell and no-cache", async () => {
+    const response = await fetch(`${baseUrl}/`);
+    expect(response.status).toBe(200);
+    expect(response.headers.get("content-type")).toBe(
+      "text/html; charset=utf-8",
+    );
+    expect(response.headers.get("cache-control")).toBe("no-cache");
+    expect(await response.text()).toBe(FIXTURE_FILES["index.html"]);
+  });
+
+  it("serves a dynamic deep link its placeholder document", async () => {
+    const response = await fetch(`${baseUrl}/sessions/ses_abc123`);
+    expect(response.status).toBe(200);
+    expect(await response.text()).toBe(
+      FIXTURE_FILES["sessions/__placeholder__.html"],
+    );
+  });
+
+  it("serves RSC flight payloads for dynamic routes as text/plain", async () => {
+    const flat = await fetch(`${baseUrl}/sessions/ses_abc123.txt`);
+    expect(flat.status).toBe(200);
+    expect(flat.headers.get("content-type")).toBe("text/plain; charset=utf-8");
+    expect(await flat.text()).toBe("flight:session");
+
+    const nested = await fetch(
+      `${baseUrl}/sessions/ses_abc123/__next.sessions.txt`,
+    );
+    expect(nested.status).toBe(200);
+    expect(await nested.text()).toBe("flight:nested-session");
+  });
+
+  it("serves unknown URLs the real 404 page WITH a 404 status", async () => {
+    const response = await fetch(`${baseUrl}/zz-definitely/zz-not/zz-here`);
+    expect(response.status).toBe(404);
+    expect(response.headers.get("content-type")).toBe(
+      "text/html; charset=utf-8",
+    );
+    expect(await response.text()).toBe(FIXTURE_FILES["404.html"]);
+  });
+
+  it("301s trailing slashes to the canonical URL, query intact", async () => {
+    const response = await fetch(`${baseUrl}/conversations/?tab=all`, {
+      redirect: "manual",
+    });
+    expect(response.status).toBe(301);
+    expect(response.headers.get("location")).toBe("/conversations?tab=all");
+  });
+
+  it("marks hashed build assets immutable and the embed loader short-lived", async () => {
+    const chunk = await fetch(`${baseUrl}/_next/static/chunks/app-1a2b3c.js`);
+    expect(chunk.status).toBe(200);
+    expect(chunk.headers.get("cache-control")).toBe(
+      "public, max-age=31536000, immutable",
+    );
+    const embed = await fetch(`${baseUrl}/embed.js`);
+    expect(embed.headers.get("cache-control")).toBe("public, max-age=300");
+  });
+
+  it("answers HEAD with the document's headers and no body", async () => {
+    const response = await fetch(`${baseUrl}/conversations`, {
+      method: "HEAD",
+    });
+    expect(response.status).toBe(200);
+    expect(response.headers.get("content-length")).toBe(
+      String(FIXTURE_FILES["conversations.html"]!.length),
+    );
+    expect(await response.text()).toBe("");
+  });
+
+  it("rejects malformed percent-escapes with the 404 page", async () => {
+    const response = await fetch(`${baseUrl}/%zz`);
+    expect(response.status).toBe(404);
+    expect(await response.text()).toBe(FIXTURE_FILES["404.html"]);
+  });
+});
+
+describe("/config.json synthesis", () => {
+  it("derives apiUrl from the request Host and forbids caching", async () => {
+    const response = await fetch(`${baseUrl}/config.json`);
+    expect(response.status).toBe(200);
+    expect(response.headers.get("content-type")).toBe("application/json");
+    expect(response.headers.get("cache-control")).toBe(
+      "no-cache, no-store, must-revalidate",
+    );
+    expect(await response.json()).toEqual({
+      apiUrl: `http://127.0.0.1:${port}`,
+      appUrl: "",
+      authMode: "disabled",
+      oidcIssuer: "",
+      oidcClientId: "",
+      oidcAudience: "",
+    });
+  });
+});
+
+describe("the guard: RPC and /v1/* flow exactly as without the lane", () => {
+  it("keeps the adapter's terse 404 for unknown /v1/proxy/* (CW-10)", async () => {
+    const response = await fetch(`${baseUrl}/v1/proxy/does-not-exist`);
+    expect(response.status).toBe(404);
+    expect(response.headers.get("content-type")).not.toBe(
+      "text/html; charset=utf-8",
+    );
+  });
+
+  it("leaves service-shaped GETs to the adapter, not the 404 page", async () => {
+    const response = await fetch(`${baseUrl}/grpc.health.v1.Health/Check`);
+    expect(response.headers.get("content-type")).not.toBe(
+      "text/html; charset=utf-8",
+    );
+  });
+
+  it("answers RPC preflights on console-looking paths (CORS untouched)", async () => {
+    const response = await fetch(`${baseUrl}/conversations`, {
+      method: "OPTIONS",
+      headers: {
+        Origin: "http://localhost:3000",
+        "Access-Control-Request-Method": "POST",
+      },
+    });
+    expect(response.status).toBe(200);
+    expect(response.headers.get("access-control-allow-origin")).toBe(
+      "http://localhost:3000",
+    );
+  });
+
+  it("serves native gRPC through the adapter with the lane installed", async () => {
+    const client = createClient(Health, createGrpcTransport({ baseUrl }));
+    const check = await client.check({});
+    expect(check.status).toBe(ServingStatus.SERVING);
+  });
+});
+
+describe("HTTP/2 stack", () => {
+  it("serves console documents over a prior-knowledge h2c session", async () => {
+    const session = http2Connect(baseUrl);
+    try {
+      const { status, body } = await new Promise<{
+        status: number;
+        body: string;
+      }>((resolve, reject) => {
+        session.on("error", reject);
+        const stream = session.request({
+          ":method": "GET",
+          ":path": "/sessions/ses_abc123",
+        });
+        let status = 0;
+        stream.on("response", (headers) => {
+          status = Number(headers[":status"]);
+        });
+        const chunks: Buffer[] = [];
+        stream.on("data", (chunk: Buffer) => chunks.push(chunk));
+        stream.on("end", () =>
+          resolve({ status, body: Buffer.concat(chunks).toString("utf8") }),
+        );
+        stream.on("error", reject);
+      });
+      expect(status).toBe(200);
+      expect(body).toBe(FIXTURE_FILES["sessions/__placeholder__.html"]);
+    } finally {
+      session.close();
+    }
+  });
+});
+
+describe("asset discovery", () => {
+  it("models a missing or empty export as absence, not an error", () => {
+    expect(
+      resolveConsoleAssets(
+        path.join(fixtureRoot, "zz-does-not-exist"),
+        silentLogger,
+      ),
+    ).toBeUndefined();
+    const empty = mkdtempSync(path.join(tmpdir(), "console-empty-"));
+    try {
+      expect(resolveConsoleAssets(empty, silentLogger)).toBeUndefined();
+    } finally {
+      rmSync(empty, { recursive: true, force: true });
+    }
+  });
+});