@powerhousedao/switchboard 6.2.3-dev.5 → 6.2.3-dev.51

package/test/boot-without-require-signatures.test.ts

@@ -0,0 +1,74 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ILogger } from "document-model";
+import { describe, expect, it, vi } from "vitest";
+import { startSwitchboard } from "../src/server.mjs";
+
+function stubLogger(): ILogger & { info: ReturnType<typeof vi.fn> } {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger & { info: ReturnType<typeof vi.fn> };
+}
+
+describe("booting Switchboard", () => {
+  it("has no REQUIRE_SIGNATURES flag, and ignores the variable", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "switchboard-signatures-"));
+    const previous = {
+      reactorDb: process.env.PH_REACTOR_DATABASE_URL,
+      requireSignatures: process.env.REQUIRE_SIGNATURES,
+    };
+    process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+    process.env.REQUIRE_SIGNATURES = "true";
+    const logger = stubLogger();
+    let switchboard: Awaited<ReturnType<typeof startSwitchboard>> | undefined;
+
+    try {
+      switchboard = await startSwitchboard({
+        workflows: { enabled: false },
+        dbPath: join(tempRoot, "read-model"),
+        port: 0,
+        mcp: false,
+        disableLocalPackages: true,
+        identity: { keypairPath: join(tempRoot, "identity.json") },
+        logger,
+      });
+
+      const flagLog = logger.info.mock.calls.find(
+        ([message]) => message === "Feature flags: @flags",
+      );
+      expect(flagLog).toBeDefined();
+      expect(JSON.parse(flagLog![1] as string)).not.toHaveProperty(
+        "REQUIRE_SIGNATURES",
+      );
+
+      const created = await switchboard.reactor.createEmpty(
+        "powerhouse/document-model",
+      );
+      expect(created.header.id).toBeTruthy();
+
+      await switchboard.shutdown();
+      switchboard = undefined;
+    } finally {
+      await switchboard?.shutdown();
+      for (const [name, value] of [
+        ["PH_REACTOR_DATABASE_URL", previous.reactorDb],
+        ["REQUIRE_SIGNATURES", previous.requireSignatures],
+      ] as const) {
+        if (value === undefined) {
+          delete process.env[name];
+        } else {
+          process.env[name] = value;
+        }
+      }
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  }, 60_000);
+});

package/test/boot-worker-trust-policy.test.ts

@@ -0,0 +1,90 @@
+import type { ILogger } from "document-model";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type * as RenownModule from "../src/renown.js";
+import { startSwitchboard } from "../src/server.mjs";
+
+vi.mock("../src/renown.js", async (importOriginal) => ({
+  ...(await importOriginal<typeof RenownModule>()),
+  initRenown: vi.fn().mockRejectedValue(new Error("Renown is unreachable")),
+}));
+
+const TRUST_FAILURE =
+  /REACTOR_WORKERS[\s\S]*REACTOR_AUTH_ENFORCEMENT[\s\S]*RENOWN_SOURCE/;
+const ENV_KEYS = [
+  "PH_REACTOR_DATABASE_URL",
+  "RENOWN_SOURCE",
+  "REACTOR_DOCUMENT_DECISIONS",
+  "REACTOR_AUTH_ENFORCEMENT",
+] as const;
+
+function stubLogger(): ILogger {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger;
+}
+
+describe("booting with pooled workers under authEnforcement", () => {
+  let tempRoot: string;
+  let previous: Partial<Record<(typeof ENV_KEYS)[number], string>>;
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(join(tmpdir(), "switchboard-worker-trust-"));
+    previous = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+    process.env.REACTOR_DOCUMENT_DECISIONS = "true";
+    process.env.REACTOR_AUTH_ENFORCEMENT = "true";
+  });
+
+  afterEach(async () => {
+    for (const key of ENV_KEYS) {
+      if (previous[key] === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = previous[key];
+      }
+    }
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  function boot(numWorkers: number) {
+    return startSwitchboard({
+      workflows: { enabled: false },
+      dbPath: join(tempRoot, "read-model"),
+      port: 0,
+      mcp: false,
+      disableLocalPackages: true,
+      logger: stubLogger(),
+      workerPool: { numWorkers },
+    });
+  }
+
+  it("fails with a self Renown source", async () => {
+    process.env.RENOWN_SOURCE = "self";
+
+    await expect(boot(2)).rejects.toThrow(TRUST_FAILURE);
+  });
+
+  // Postgres is the next requirement a pooled boot has; reaching it passes the check.
+  it("passes the check with a remote Renown source", async () => {
+    process.env.RENOWN_SOURCE = "remote";
+
+    await expect(boot(2)).rejects.toThrow(/requires a Postgres/);
+  });
+
+  // No loaded package serves the renown read model here; reaching that check passes this one.
+  it("passes the check without workers", async () => {
+    process.env.RENOWN_SOURCE = "self";
+
+    await expect(boot(0)).rejects.toThrow(/no loaded package serves/);
+  }, 60_000);
+});

package/test/boot-workflow-singleton-conflict.test.ts

@@ -0,0 +1,107 @@
+// Losing the workflow singleton claim must not take the whole API down.
+//
+// It used to: WorkflowSingletonConflictError propagated out of startSwitchboard
+// and aborted the boot. With the old random per-process owner name, an unclean
+// kill left a lease nobody could re-claim, so every restart inside the 60s TTL
+// crash-looped the entire Switchboard — inspection, GraphQL, sync and all —
+// over a component this host is merely not allowed to run.
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type * as WorkflowEngine from "@powerhousedao/reactor-workflow";
+import type { ILogger } from "document-model";
+import { describe, expect, it, vi } from "vitest";
+
+const HOLDER = "another-live-replica";
+const HELD_UNTIL = "2030-01-01T00:00:00.000Z";
+
+// The lease itself is the engine's to test (reactor-workflow,
+// singleton-lease.test.ts). What is under test here is what THIS host does
+// when the claim is refused, so only the claim is faked.
+vi.mock("@powerhousedao/reactor-workflow", async (importOriginal) => {
+  const actual = await importOriginal<typeof WorkflowEngine>();
+  return {
+    ...actual,
+    acquireWorkflowSingletonLease: () => {
+      const error = new Error(
+        `Workflow execution is a singleton and "${HOLDER}" holds it until ${HELD_UNTIL}`,
+      );
+      error.name = "WorkflowSingletonConflictError";
+      return Promise.reject(
+        Object.assign(error, {
+          owner: HOLDER,
+          expiresAt: HELD_UNTIL,
+          wouldBe: "this-host",
+        }),
+      );
+    },
+  };
+});
+
+const { startSwitchboard } = await import("../src/server.mjs");
+
+function stubLogger(): ILogger & { warn: ReturnType<typeof vi.fn> } {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger & { warn: ReturnType<typeof vi.fn> };
+}
+
+describe("booting Switchboard when another process holds the singleton", () => {
+  it("boots the API without the workflow runtime, naming the owner", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "switchboard-wf-conflict-"));
+    const previousReactorDb = process.env.PH_REACTOR_DATABASE_URL;
+    process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+    const logger = stubLogger();
+    let switchboard: Awaited<ReturnType<typeof startSwitchboard>> | undefined;
+
+    try {
+      // The boot RESOLVES. That is the whole finding.
+      switchboard = await startSwitchboard({
+        workflows: { enabled: true },
+        dbPath: join(tempRoot, "read-model"),
+        port: 0,
+        mcp: false,
+        disableLocalPackages: true,
+        identity: { keypairPath: join(tempRoot, "identity.json") },
+        logger,
+      });
+
+      // The API is up and serving: the reactor answers, the document models
+      // are registered, everything but workflows works.
+      const { results } = await switchboard.reactor.getDocumentModelModules();
+      expect(results.length).toBeGreaterThan(0);
+
+      // And the runtime is absent, said so rather than half-present.
+      expect(switchboard.workflowTriggers).toBeUndefined();
+
+      // Warned, not errored into silence, and the warning names who holds it
+      // and how to get workflows back.
+      const warning = logger.warn.mock.calls
+        .map((call) => String(call[0]))
+        .find((line) => line.includes("workflow singleton"));
+      expect(warning).toBeDefined();
+      expect(warning).toContain(HOLDER);
+      expect(warning).toContain(HELD_UNTIL);
+      expect(warning).toContain("WITHOUT the workflow runtime");
+      expect(warning).toContain("PH_WORKFLOWS_SINGLETON_OWNER");
+
+      await switchboard.shutdown();
+      switchboard = undefined;
+    } finally {
+      await switchboard?.shutdown();
+      if (previousReactorDb === undefined) {
+        delete process.env.PH_REACTOR_DATABASE_URL;
+      } else {
+        process.env.PH_REACTOR_DATABASE_URL = previousReactorDb;
+      }
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  }, 60_000);
+});

package/test/boot-workflow-singleton-retry.test.ts

@@ -0,0 +1,133 @@
+// A Switchboard refused the workflow singleton at boot retries the claim and
+// starts workflows once the holder lets go. The runtime it composes then has
+// to be reachable: its GraphQL face mounted, not only registered.
+import { mkdtemp, rm } from "node:fs/promises";
+import { createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  acquireWorkflowSingletonLease,
+  type WorkflowSingletonLease,
+} from "@powerhousedao/reactor-workflow";
+import {
+  createRelationalDb,
+  type IRelationalDb,
+} from "@powerhousedao/shared/processors";
+import type { ILogger } from "document-model";
+import { Kysely, PostgresDialect } from "kysely";
+import pg from "pg";
+import { describe, expect, it, vi } from "vitest";
+import { startSwitchboard } from "../src/server.mjs";
+
+const PG_URL = process.env.REACTOR_TEST_PG_URL;
+const DATABASE = "switchboard_workflow_retry";
+
+function stubLogger(): ILogger {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger;
+}
+
+async function freePort(): Promise<number> {
+  const server = createServer();
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  await new Promise((resolve) => server.close(resolve));
+  if (address === null || typeof address === "string") {
+    throw new Error("no port");
+  }
+  return address.port;
+}
+
+async function queryHealth(port: number): Promise<string | undefined> {
+  const response = await fetch(`http://127.0.0.1:${port}/graphql`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ query: "{ workflowRuntime { health } }" }),
+  });
+  const body = (await response.json()) as {
+    data?: { workflowRuntime?: { health?: string } };
+  };
+  return body.data?.workflowRuntime?.health;
+}
+
+describe.skipIf(!PG_URL)(
+  "a Switchboard that claims the workflow singleton after boot [Postgres]",
+  () => {
+    it("serves the workflow GraphQL API once it has the claim", async () => {
+      const admin = new pg.Pool({ connectionString: PG_URL });
+      await admin.query(`DROP DATABASE IF EXISTS "${DATABASE}" WITH (FORCE)`);
+      await admin.query(`CREATE DATABASE "${DATABASE}"`);
+      const url = new URL(PG_URL!);
+      url.pathname = `/${DATABASE}`;
+      const readModelUrl = url.toString();
+      const holderDb = new Kysely<unknown>({
+        dialect: new PostgresDialect({
+          pool: new pg.Pool({ connectionString: readModelUrl, max: 2 }),
+        }),
+      });
+      const tempRoot = await mkdtemp(join(tmpdir(), "switchboard-wf-retry-"));
+      const previousReactorDb = process.env.PH_REACTOR_DATABASE_URL;
+      process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+      let holder: WorkflowSingletonLease | undefined;
+      let switchboard: Awaited<ReturnType<typeof startSwitchboard>> | undefined;
+      try {
+        // Another live host holds the singleton over the same journal.
+        holder = await acquireWorkflowSingletonLease({
+          relationalDb: createRelationalDb(holderDb) as IRelationalDb,
+          logger: stubLogger(),
+          owner: "the-other-host",
+        });
+
+        switchboard = await startSwitchboard({
+          workflows: { enabled: true },
+          dbPath: readModelUrl,
+          port: await freePort(),
+          strictPort: true,
+          mcp: false,
+          disableLocalPackages: true,
+          identity: { keypairPath: join(tempRoot, "identity.json") },
+          logger: stubLogger(),
+        });
+        expect(switchboard.workflowTriggers).toBeUndefined();
+        expect(await queryHealth(switchboard.port)).toBeUndefined();
+
+        await holder.release();
+        holder = undefined;
+
+        const port = switchboard.port;
+        await vi.waitFor(
+          async () => expect(await queryHealth(port)).toBe("ok"),
+          { timeout: 60_000, interval: 500 },
+        );
+        expect(switchboard.workflowTriggers).toEqual({ status: "available" });
+
+        await switchboard.shutdown();
+        switchboard = undefined;
+      } finally {
+        await holder?.release();
+        await switchboard?.shutdown();
+        await holderDb.destroy();
+        if (previousReactorDb === undefined) {
+          delete process.env.PH_REACTOR_DATABASE_URL;
+        } else {
+          process.env.PH_REACTOR_DATABASE_URL = previousReactorDb;
+        }
+        // Not forced: terminating a pool's idle connections under it raises
+        // an unhandled error. A database left behind is dropped next run.
+        await admin
+          .query(`DROP DATABASE IF EXISTS "${DATABASE}"`)
+          .catch(() => undefined);
+        await admin.end();
+        await rm(tempRoot, { recursive: true, force: true });
+      }
+    }, 120_000);
+  },
+);

package/test/builder-defaults.test.ts

@@ -0,0 +1,80 @@
+import type { ISigner } from "@powerhousedao/shared/document-model";
+import {
+  ReactorBuilder,
+  ReactorClientBuilder,
+  type FactorySpec,
+} from "@powerhousedao/reactor";
+import type { IRenown } from "@renown/sdk/node";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { applySwitchboardReactorDefaults } from "../src/builder-defaults.mjs";
+import {
+  getRenownSignerConfig,
+  getRenownWorkerSignerSpec,
+} from "../src/renown.js";
+
+const USER = { address: "0xswitchboard", networkId: "eip155", chainId: 1 };
+
+function stubRenown(user = USER): IRenown {
+  const signer = {
+    user,
+    app: { name: "switchboard", key: "did:key:zSwitchboard" },
+  } as unknown as ISigner;
+  return { signer } as unknown as IRenown;
+}
+
+describe("applySwitchboardReactorDefaults", () => {
+  it("gives the reactor the signer and its worker spec", () => {
+    const reactorBuilder = new ReactorBuilder();
+    const clientBuilder = new ReactorClientBuilder();
+    const reactorWithSigner = vi.spyOn(reactorBuilder, "withSigner");
+    const clientWithSigner = vi.spyOn(clientBuilder, "withSigner");
+    const signer = getRenownSignerConfig(stubRenown(), ".ph/key.json");
+
+    applySwitchboardReactorDefaults(reactorBuilder, clientBuilder, {
+      includeBaseModels: false,
+      signalHandlers: false,
+      signer,
+    });
+
+    expect(clientWithSigner).toHaveBeenCalledWith(signer);
+    expect(reactorWithSigner).toHaveBeenCalledWith(
+      signer.signer,
+      signer.workerSigner,
+    );
+    expect(reactorBuilder.hasSigner()).toBe(true);
+  });
+});
+
+describe("getRenownWorkerSignerSpec", () => {
+  it("points workers at createNodeRenownSigner over the stored key", () => {
+    const spec: FactorySpec = getRenownWorkerSignerSpec(
+      stubRenown(),
+      ".ph/key.json",
+    );
+
+    expect(spec.module.exportName).toBe("createNodeRenownSigner");
+    const filePath = "filePath" in spec.module ? spec.module.filePath : "";
+    expect(existsSync(filePath)).toBe(true);
+    expect(spec.initArgs).toEqual({
+      appName: "switchboard",
+      keypairPath: resolve(".ph/key.json"),
+      did: "did:key:zSwitchboard",
+      user: USER,
+    });
+  });
+
+  it("leaves the user out when none is logged in", () => {
+    const renown = stubRenown();
+    (renown.signer as { user?: unknown }).user = undefined;
+
+    const spec = getRenownWorkerSignerSpec(renown);
+
+    expect(spec.initArgs).toEqual({
+      appName: "switchboard",
+      keypairPath: resolve(".ph/.keypair.json"),
+      did: "did:key:zSwitchboard",
+    });
+  });
+});

package/test/create-signature-policy.test.ts

@@ -0,0 +1,69 @@
+import { ReactorBuilder, ReactorClientBuilder } from "@powerhousedao/reactor";
+import { describe, expect, it, vi } from "vitest";
+import { applySwitchboardReactorDefaults } from "../src/builder-defaults.mjs";
+import { resolveCreateSignaturePolicy } from "../src/create-signature-policy.mjs";
+
+describe("resolveCreateSignaturePolicy", () => {
+  it("defaults to v2-required with a signer", () => {
+    expect(resolveCreateSignaturePolicy({}, { hasSigner: true })).toBe(
+      "v2-required",
+    );
+  });
+
+  it("reads CREATE_SIGNATURE_POLICY", () => {
+    expect(
+      resolveCreateSignaturePolicy(
+        { CREATE_SIGNATURE_POLICY: "legacy" },
+        { hasSigner: true },
+      ),
+    ).toBe("legacy");
+    expect(
+      resolveCreateSignaturePolicy(
+        { CREATE_SIGNATURE_POLICY: " v2-required " },
+        { hasSigner: true },
+      ),
+    ).toBe("v2-required");
+  });
+
+  it("refuses an unknown value", () => {
+    expect(() =>
+      resolveCreateSignaturePolicy(
+        { CREATE_SIGNATURE_POLICY: "v2" },
+        { hasSigner: true },
+      ),
+    ).toThrow(/CREATE_SIGNATURE_POLICY/);
+  });
+
+  it("falls back to legacy with a warning when there is no signer", () => {
+    const warn = vi.fn();
+
+    expect(
+      resolveCreateSignaturePolicy({}, { hasSigner: false, logger: { warn } }),
+    ).toBe("legacy");
+    expect(warn).toHaveBeenCalledOnce();
+
+    warn.mockClear();
+    expect(
+      resolveCreateSignaturePolicy(
+        { CREATE_SIGNATURE_POLICY: "legacy" },
+        { hasSigner: false, logger: { warn } },
+      ),
+    ).toBe("legacy");
+    expect(warn).not.toHaveBeenCalled();
+  });
+});
+
+describe("applySwitchboardReactorDefaults", () => {
+  it("hands the creation policy to the client builder", () => {
+    const clientBuilder = new ReactorClientBuilder();
+    const withPolicy = vi.spyOn(clientBuilder, "withCreateSignaturePolicy");
+
+    applySwitchboardReactorDefaults(new ReactorBuilder(), clientBuilder, {
+      includeBaseModels: false,
+      signalHandlers: false,
+      createSignaturePolicy: "legacy",
+    });
+
+    expect(withPolicy).toHaveBeenCalledWith("legacy");
+  });
+});

package/test/durable-node-fs-pg16.test.ts

@@ -0,0 +1,80 @@
+import { createDurableNodeFs } from "@powerhousedao/reactor-api/pglite-node";
+import nodeFs, { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { loadNodeFsClass, loadPGliteModule } from "../src/pglite-version.js";
+
+// A fresh initdb takes ~10 s under suite load; the Windows runner is slower.
+const BOOT = 180_000;
+const COMMITS = 10;
+const RM = { recursive: true, force: true, maxRetries: 10 } as const;
+
+describe("durable NodeFS over pglite-legacy-02 (PG16)", () => {
+  const tempDirs: string[] = [];
+
+  afterEach(async () => {
+    for (const dir of tempDirs.splice(0)) {
+      await fs.rm(dir, RM);
+    }
+  });
+
+  it(
+    "opens a PG16 dir over pglite-legacy-02 with the durable fs",
+    async () => {
+      const dir = await fs.mkdtemp(path.join(os.tmpdir(), "durable-pg16-"));
+      tempDirs.push(dir);
+      const counts = { fsync: 0, fdatasync: 0 };
+      const hostFs = {
+        fsyncSync: (fd: number) => {
+          counts.fsync++;
+          nodeFs.fsyncSync(fd);
+        },
+        fdatasyncSync: (fd: number) => {
+          counts.fdatasync++;
+          nodeFs.fdatasyncSync(fd);
+        },
+      };
+      const [{ PGlite }, NodeFS] = await Promise.all([
+        loadPGliteModule(16),
+        loadNodeFsClass(16),
+      ]);
+      const pg = new PGlite({
+        fs: createDurableNodeFs(NodeFS, dir, {
+          hostFs,
+          maintenanceIntervalMs: 0,
+        }),
+      });
+      try {
+        await pg.waitReady;
+        const version = await pg.query<{ v: string }>(
+          "SELECT current_setting('server_version_num') AS v",
+        );
+        expect(version.rows[0].v.startsWith("16")).toBe(true);
+        await pg.exec("CREATE TABLE t (v int)");
+        const before = counts.fdatasync;
+        for (let i = 0; i < COMMITS; i++) {
+          await pg.exec(`INSERT INTO t VALUES (${i})`);
+        }
+        const perCommit = counts.fdatasync - before;
+        const fsyncBefore = counts.fsync;
+        await pg.exec("CHECKPOINT");
+        const checkpointSyncs = counts.fsync - fsyncBefore;
+        console.info(
+          `pglite-legacy-02: ${perCommit} host fdatasync over ${COMMITS} commits, ${checkpointSyncs} host fsync on CHECKPOINT, ${fsyncBefore} host fsync since open`,
+        );
+        // Pins decision 5's outcome on 0.2.17: WAL goes through
+        // open_datasync, which never reaches the fdatasync hook, so commits
+        // are not synced; the stream-op patch does take (CHECKPOINT syncs).
+        expect(perCommit).toBe(0);
+        expect(checkpointSyncs).toBeGreaterThan(0);
+      } finally {
+        await pg.close();
+      }
+      expect(
+        (await fs.readFile(path.join(dir, "PG_VERSION"), "utf8")).trim(),
+      ).toBe("16");
+    },
+    BOOT,
+  );
+});