@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/src/browser/pdf.ts

@@ -1,62 +0,0 @@
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { writeOutput } from "./screenshot.js";
-
-/** Paper sizes in centimetres, as the browser wants them */
-const PAPER = {
-  Letter: { width: 21.59, height: 27.94 },
-  Legal: { width: 21.59, height: 35.56 },
-  Tabloid: { width: 27.94, height: 43.18 },
-  Ledger: { width: 43.18, height: 27.94 },
-  A0: { width: 84.1, height: 118.9 },
-  A1: { width: 59.4, height: 84.1 },
-  A2: { width: 42, height: 59.4 },
-  A3: { width: 29.7, height: 42 },
-  A4: { width: 21, height: 29.7 },
-  A5: { width: 14.8, height: 21 },
-  A6: { width: 10.5, height: 14.8 },
-} as const;
-
-export type PaperFormat = keyof typeof PAPER;
-
-export interface PdfOptions {
-  /** Also write the PDF here (folders are created) */
-  path?: string;
-  landscape?: boolean;
-  /** 0.1 to 2 */
-  scale?: number;
-  /** Pages to print, e.g. `["1-3", 5]` */
-  pageRanges?: (string | number)[];
-  /** Page margins in centimetres */
-  margin?: { top?: number; bottom?: number; left?: number; right?: number };
-  /** Print background colours and images */
-  printBackground?: boolean;
-  /** Paper size. Without one the browser's default is used */
-  format?: PaperFormat;
-}
-
-/** Renders the page as a PDF and returns it (also written to `options.path`) */
-export async function printPdf(
-  connector: BiDiConnector,
-  context: string,
-  options: PdfOptions = {},
-): Promise<Buffer> {
-  const { scale, format } = options;
-  if (scale !== undefined && !(scale >= 0.1 && scale <= 2)) {
-    throw new RangeError("pdf(): scale must be between 0.1 and 2");
-  }
-  if (format !== undefined && !(format in PAPER)) {
-    throw new RangeError(`pdf(): unknown paper format "${format}"; use one of ${Object.keys(PAPER).join(", ")}`);
-  }
-  const { data } = await connector.send("browsingContext.print", {
-    context,
-    ...(options.landscape && { orientation: "landscape" as const }),
-    ...(scale !== undefined && { scale }),
-    ...(options.pageRanges && { pageRanges: options.pageRanges }),
-    ...(options.margin && { margin: options.margin }),
-    ...(options.printBackground && { background: true }),
-    ...(format && { page: { ...PAPER[format] } }),
-  });
-  const pdf = Buffer.from(data, "base64");
-  await writeOutput(options.path, pdf);
-  return pdf;
-}

package/src/browser/screenshot.ts

@@ -1,65 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-
-export interface ScreenshotOptions {
-  /** Also write the image here (folders are created) */
-  path?: string;
-  /** The whole document instead of the viewport */
-  fullPage?: boolean;
-  /** Only this part: in viewport coordinates, or document coordinates with `fullPage` */
-  clip?: { x: number; y: number; width: number; height: number };
-  /** @default "png" */
-  type?: "png" | "jpeg";
-  /** 0 to 100, jpeg only */
-  quality?: number;
-}
-
-/** The options a single element's screenshot takes: the image format and where to write it */
-export type ElementScreenshotOptions = Pick<ScreenshotOptions, "path" | "type" | "quality">;
-
-const MIME = { png: "image/png", jpeg: "image/jpeg" } as const;
-
-/** The `format` of a capture command; validates the type/quality combination */
-function imageFormat({ type, quality }: Pick<ScreenshotOptions, "type" | "quality">) {
-  if (quality !== undefined) {
-    if (type !== "jpeg") throw new RangeError("screenshot(): quality only applies to jpeg");
-    if (!Number.isFinite(quality) || quality < 0 || quality > 100) {
-      throw new RangeError("screenshot(): quality must be between 0 and 100");
-    }
-  }
-  if (type === undefined) return undefined;
-  return { type: MIME[type], ...(quality !== undefined && { quality: quality / 100 }) };
-}
-
-/**
- * Captures the page (or, with `element`, that element) and returns the image. Writes it to `options.path` too.
- * The browser answers Base64.
- */
-export async function takeScreenshot(
-  connector: BiDiConnector,
-  context: string,
-  options: ScreenshotOptions = {},
-  element?: { sharedId: string },
-): Promise<Buffer> {
-  const format = imageFormat(options);
-  const clip = element
-    ? { type: "element" as const, element: { sharedId: element.sharedId } }
-    : options.clip && { type: "box" as const, ...options.clip };
-  const { data } = await connector.send("browsingContext.captureScreenshot", {
-    context,
-    ...(options.fullPage && { origin: "document" as const }),
-    ...(format && { format }),
-    ...(clip && { clip }),
-  });
-  const image = Buffer.from(data, "base64");
-  await writeOutput(options.path, image);
-  return image;
-}
-
-/** Writes `data` to `file`, creating the folders; nothing happens without a path */
-export async function writeOutput(file: string | undefined, data: Buffer): Promise<void> {
-  if (!file) return;
-  await mkdir(path.dirname(file), { recursive: true });
-  await writeFile(file, data);
-}

package/src/browser/transfers.browser-test.ts

@@ -1,180 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { createServer, type Server } from "node:http";
-import type { AddressInfo, Socket } from "node:net";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { after, before, test } from "node:test";
-import { callFunction } from "../script/call-function.js";
-import { setContent } from "../testing/browser-fixture.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { Browser } from "./browser.js";
-import { DownloadError } from "./download.js";
-import type Page from "./page.js";
-
-let browser: Browser;
-let page: Page;
-let server: Server;
-let base: string;
-let downloadsDir: string;
-const sockets = new Set<Socket>();
-const uploads = mkdtempSync(path.join(tmpdir(), "samurai-uploads-"));
-
-before(async () => {
-  server = createServer((req, res) => {
-    const p = (req.url ?? "").split("?")[0];
-    if (p === "/file") {
-      res.writeHead(200, { "content-type": "text/csv", "content-disposition": 'attachment; filename="report.csv"' }).end("a,b\n1,2\n");
-    } else if (p === "/broken") {
-      res.writeHead(200, { "content-type": "application/octet-stream", "content-disposition": 'attachment; filename="broken.bin"', "content-length": "100000" });
-      res.write("partial");
-      setTimeout(() => res.destroy(), 150);
-    } else if (p === "/frame") {
-      res.setHeader("content-type", "text/html").end(`<body><a id="dl" href="/file">in frame</a></body>`);
-    } else {
-      res.setHeader("content-type", "text/html").end("<!doctype html><body>page</body>");
-    }
-  });
-  server.on("connection", (socket) => {
-    sockets.add(socket);
-    socket.on("close", () => sockets.delete(socket));
-  });
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-  base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
-  ({ browser, page } = await Browser.launch("firefox", { port: 9250, headless: true }));
-  downloadsDir = browser.downloadsDir!;
-  await page.navigateTo(`${base}/`);
-});
-
-after(async () => {
-  await page.dispose();
-  await browser?.close();
-  sockets.forEach((socket) => socket.destroy());
-  await new Promise((resolve) => server.close(resolve));
-  rmSync(uploads, { recursive: true, force: true });
-  if (downloadsDir) rmSync(downloadsDir, { recursive: true, force: true });
-});
-
-const OPTIONS = { timeout: 40000 };
-const connector = () => (page as unknown as { biDiConnector: BiDiConnector }).biDiConnector;
-const evaluate = <T>(source: string) => callFunction<T>(connector(), page.contextId, source);
-const upload = (name: string, content = name) => {
-  const full = path.join(uploads, name);
-  writeFileSync(full, content);
-  return full;
-};
-
-test("the browser saves downloads in the folder the framework made for it", OPTIONS, async () => {
-  assert.ok(downloadsDir, "the browser could be told where to save");
-  assert.ok(existsSync(downloadsDir));
-  assert.match(path.basename(downloadsDir), /^dl-/);
-});
-
-test("waitForDownload reports the download when it starts; path() gives the saved file", OPTIONS, async () => {
-  await setContent(page, `<a id="dl" href="${base}/file">download</a>`);
-  const download = await page.waitForDownload({ trigger: () => page.locator("a[@id='dl']").click({ timeout: 5000 }) });
-  assert.equal(download.suggestedFilename(), "report.csv");
-  assert.equal(download.url(), `${base}/file`);
-  const file = await download.path();
-  assert.equal(path.dirname(file), downloadsDir);
-  assert.equal(readFileSync(file, "utf8"), "a,b\n1,2\n");
-  assert.equal(await download.failure(), null);
-});
-
-test("a second download with the same name is saved under another name", OPTIONS, async () => {
-  await setContent(page, `<a id="dl" href="${base}/file?again">download</a>`);
-  const download = await page.waitForDownload({ trigger: () => page.locator("a[@id='dl']").click({ timeout: 5000 }) });
-  const file = await download.path();
-  assert.notEqual(path.basename(file), "report.csv");
-  assert.match(path.basename(file), /^report.*\.csv$/);
-  assert.ok(readdirSync(downloadsDir).length >= 2);
-});
-
-test("a download the server breaks off is cancelled", OPTIONS, async () => {
-  await setContent(page, `<a id="broken" href="${base}/broken">broken</a>`);
-  const download = await page.waitForDownload({ trigger: () => page.locator("a[@id='broken']").click({ timeout: 5000 }) });
-  assert.equal(download.suggestedFilename(), "broken.bin");
-  await assert.rejects(download.path(), (err: unknown) => {
-    assert.ok(err instanceof DownloadError);
-    assert.equal(err.reason, "canceled");
-    assert.equal(err.url, `${base}/broken`);
-    return true;
-  });
-  assert.equal(await download.failure(), "canceled");
-});
-
-test("a download started from an iframe belongs to the page", OPTIONS, async () => {
-  await page.navigateTo(`${base}/?frames`);
-  await evaluate(`() => { const f = document.body.appendChild(document.createElement("iframe")); f.src = "/frame"; }`);
-  await new Promise((resolve) => setTimeout(resolve, 500));
-  const seen: string[] = [];
-  page.on("download", (download) => seen.push(download.suggestedFilename()));
-  // click inside the frame through the script: pointer input is per top-level context
-  await evaluate(`() => { document.querySelector("iframe").contentDocument.getElementById("dl").click(); }`);
-  const deadline = Date.now() + 5000;
-  while (seen.length === 0 && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 50));
-  assert.equal(seen.length, 1);
-  assert.match(seen[0]!, /^report.*\.csv$/, "Firefox's suggested name already carries its (n) suffix when the name is taken");
-});
-
-test("waitForDownload times out with a message of its own", OPTIONS, async () => {
-  await assert.rejects(page.waitForDownload({ timeout: 300 }), /waitForDownload\(\): no download started within 300ms/);
-});
-
-test("a file input's picker is reported, and setFiles fills the input", OPTIONS, async () => {
-  await setContent(
-    page,
-    `<input type="file" id="f"><div id="out"></div>`,
-    `const f = document.getElementById("f");
-     f.addEventListener("change", () => { document.getElementById("out").textContent = [...f.files].map((x) => x.name).join(","); });`,
-  );
-  const picture = upload("avatar.png");
-  const chooser = await page.waitForFileChooser({ trigger: () => page.locator("input[@id='f']").click({ timeout: 5000 }) });
-  assert.equal(chooser.isMultiple(), false);
-  await chooser.setFiles(picture);
-  assert.equal(await evaluate<string>(`() => document.getElementById("out").textContent`), "avatar.png");
-});
-
-test("a picker that takes several files says so, and takes them", OPTIONS, async () => {
-  await setContent(page, `<input type="file" id="m" multiple>`);
-  const chooser = await page.waitForFileChooser({ trigger: () => page.locator("input[@id='m']").click({ timeout: 5000 }) });
-  assert.equal(chooser.isMultiple(), true);
-  await chooser.setFiles([upload("a.csv"), upload("b.csv")]);
-  assert.deepEqual(await evaluate<string[]>(`() => [...document.getElementById("m").files].map((f) => f.name)`), ["a.csv", "b.csv"]);
-});
-
-test("a single-file picker refuses two files", OPTIONS, async () => {
-  await setContent(page, `<input type="file" id="f">`);
-  const chooser = await page.waitForFileChooser({ trigger: () => page.locator("input[@id='f']").click({ timeout: 5000 }) });
-  await assert.rejects(chooser.setFiles([upload("x1.txt"), upload("x2.txt")]), /file chooser does not accept multiple files/);
-  await assert.rejects(chooser.setFiles(path.join(uploads, "missing.txt")), /file not found/);
-});
-
-test("a click on the label of a hidden input opens the picker as well", OPTIONS, async () => {
-  await setContent(page, `<label id="lab" for="f" style="display:inline-block;padding:6px">Choose</label><input type="file" id="f" style="display:none">`);
-  const chooser = await page.waitForFileChooser({ trigger: () => page.locator("label[@id='lab']").click({ timeout: 5000 }) });
-  await chooser.setFiles(upload("hidden.txt"));
-  assert.deepEqual(await evaluate<string[]>(`() => [...document.getElementById("f").files].map((f) => f.name)`), ["hidden.txt"]);
-});
-
-test("a picker nobody waits for does not hang the page", OPTIONS, async () => {
-  await setContent(page, `<input type="file" id="f"><button id="b">next</button>`);
-  await page.locator("input[@id='f']").click({ timeout: 5000 });
-  await page.locator("button[@id='b']").click({ timeout: 5000 });
-  assert.equal(await page.locator("button[@id='b']").textContent(), "next");
-});
-
-test("page.on(filechooser) sees every picker", OPTIONS, async () => {
-  await setContent(page, `<input type="file" id="f">`);
-  let count = 0;
-  page.on("filechooser", () => count++);
-  await page.locator("input[@id='f']").click({ timeout: 5000 });
-  await page.locator("input[@id='f']").click({ timeout: 5000 });
-  const deadline = Date.now() + 3000;
-  while (count < 2 && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 25));
-  assert.equal(count, 2);
-});
-
-test("waitForFileChooser times out with a message of its own", OPTIONS, async () => {
-  await assert.rejects(page.waitForFileChooser({ timeout: 300 }), /waitForFileChooser\(\): no file chooser opened within 300ms/);
-});

package/src/config/config.ts

@@ -1,33 +0,0 @@
-import type { SamuraiTestConfig } from "../types/config.js";
-import path from "path";
-import logger from "../logger/index.js";
-import { pathToFileURL } from "url";
-
-/** The whole `samurai.config.ts` of the current working directory */
-export async function loadConfig(): Promise<SamuraiTestConfig> {
-  const configUrl = path.join(process.cwd(), "samurai.config.ts");
-  logger.debug("Reading config from: %s", configUrl);
-
-  const config = (await import(pathToFileURL(configUrl).href)) as {
-    default?: SamuraiTestConfig;
-  };
-
-  if (!config.default) {
-    throw new Error(
-      "samurai.config.ts does not export defineConfig as default!",
-    );
-  }
-  return config.default;
-}
-
-export async function readConfig<K extends keyof SamuraiTestConfig>(
-  key: K,
-): Promise<SamuraiTestConfig[K]> {
-  const value = (await loadConfig())[key];
-  logger.debug("Resolved config value: ", { value });
-  return value;
-}
-
-export function defineConfig(config: SamuraiTestConfig) {
-  return config;
-}

package/src/config/default.ts

@@ -1,5 +0,0 @@
-import type { SamuraiTestConfig } from "../types/config.js";
-
-export const config: SamuraiTestConfig = {
-  srcDir: "./src",
-};

package/src/config/fixtures.test.ts

@@ -1,137 +0,0 @@
-import { after, describe, test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { inspect } from "node:util";
-import { createEnvFixture, UnknownVariableError } from "./variables.js";
-import { createSecretsFixture, loadSecrets, MissingSecretError } from "./secrets.js";
-
-describe("env fixture", () => {
-  const env = createEnvFixture("staging", { customerEmail: "sam@example.test", newCheckout: true });
-
-  test("reads variables", () => {
-    assert.equal(env.customerEmail, "sam@example.test");
-    const { newCheckout } = env;
-    assert.equal(newCheckout, true);
-  });
-
-  test("an unknown variable throws", () => {
-    assert.throws(
-      () => env.customerEmial,
-      (err) =>
-        err instanceof UnknownVariableError &&
-        err.message === 'Variable "customerEmial" is not defined in environment "staging"',
-    );
-  });
-
-  test("is read-only", () => {
-    assert.throws(() => {
-      (env as Record<string, unknown>).customerEmail = "x";
-    }, TypeError);
-  });
-
-  test("behaves like a plain object for JSON, inspect and await", async () => {
-    assert.equal(JSON.stringify(env), '{"customerEmail":"sam@example.test","newCheckout":true}');
-    assert.match(inspect(env), /customerEmail/);
-    assert.equal(await env, env);
-    assert.equal("customerEmail" in env, true);
-  });
-});
-
-describe("loadSecrets", () => {
-  const dir = mkdtempSync(path.join(tmpdir(), "samurai-secrets-"));
-  after(() => rmSync(dir, { recursive: true, force: true }));
-  writeFileSync(
-    path.join(dir, ".env.staging"),
-    [
-      "# staging secrets",
-      "",
-      "SAMURAI_SECRET_TEST_CARD=4242424242424242",
-      'SAMURAI_SECRET_CUSTOMER_PW="pa ss # word"',
-      "SAMURAI_SECRET_FROM_FILE=file",
-      "OTHER_VALUE=ignored",
-    ].join("\n"),
-  );
-
-  test("parses comments and quotes in .env files", () => {
-    const secrets = loadSecrets("staging", { cwd: dir, env: {} as unknown as NodeJS.ProcessEnv });
-    assert.deepEqual(Object.fromEntries(secrets), {
-      TEST_CARD: "4242424242424242",
-      CUSTOMER_PW: "pa ss # word",
-      FROM_FILE: "file",
-    });
-  });
-
-  test("env vars beat the file and non-prefixed keys are ignored", () => {
-    const secrets = loadSecrets("staging", {
-      cwd: dir,
-      env: { SAMURAI_SECRET_FROM_FILE: "env", SAMURAI_SECRET_ONLY_ENV: "x", PATH: "/bin" } as unknown as NodeJS.ProcessEnv,
-    });
-    assert.equal(secrets.get("FROM_FILE"), "env");
-    assert.equal(secrets.get("ONLY_ENV"), "x");
-    assert.equal(secrets.has("PATH"), false);
-  });
-
-  test("an empty value counts as unset and does not override a file value", () => {
-    const empty = mkdtempSync(path.join(tmpdir(), "samurai-secrets-empty-"));
-    try {
-      writeFileSync(path.join(empty, ".env.staging"), "SAMURAI_SECRET_A=\nSAMURAI_SECRET_B=fromfile\nSAMURAI_SECRET_C=\n");
-      const secrets = loadSecrets("staging", {
-        cwd: empty,
-        env: { SAMURAI_SECRET_B: "", SAMURAI_SECRET_C: "fromenv" } as unknown as NodeJS.ProcessEnv,
-      });
-      assert.deepEqual(Object.fromEntries(secrets), { B: "fromfile", C: "fromenv" });
-      assert.equal(secrets.has("A"), false);
-    } finally {
-      rmSync(empty, { recursive: true, force: true });
-    }
-  });
-
-  test("a missing file is fine", () => {
-    assert.deepEqual(Object.fromEntries(loadSecrets("dev", { cwd: dir, env: { SAMURAI_SECRET_A: "1" } as unknown as NodeJS.ProcessEnv })), { A: "1" });
-  });
-
-  test("names that are not UPPER_SNAKE_CASE are skipped", () => {
-    assert.equal(loadSecrets("dev", { cwd: dir, env: { SAMURAI_SECRET_lower: "x" } as unknown as NodeJS.ProcessEnv }).size, 0);
-  });
-});
-
-describe("secrets fixture", () => {
-  const secrets = createSecretsFixture("staging", new Map([["TEST_CARD", "4242424242424242"]]));
-
-  test("reads a secret", () => {
-    assert.equal(secrets.TEST_CARD, "4242424242424242");
-  });
-
-  test("a missing secret throws", () => {
-    assert.throws(
-      () => secrets.CUSTOMER_PW,
-      (err) =>
-        err instanceof MissingSecretError &&
-        err.message === 'Secret "CUSTOMER_PW" is not set (expected env var SAMURAI_SECRET_CUSTOMER_PW or .env.staging)',
-    );
-  });
-
-  test("an invalid name throws", () => {
-    assert.throws(() => secrets.testCard, { message: 'Invalid secret name "testCard" (use UPPER_SNAKE_CASE)' });
-  });
-
-  test("JSON and inspect never show values", () => {
-    assert.equal(JSON.stringify(secrets), '{"TEST_CARD":"••••"}');
-    assert.equal(JSON.stringify({ secrets }), '{"secrets":{"TEST_CARD":"••••"}}');
-    assert.doesNotMatch(inspect(secrets), /4242/);
-    assert.match(inspect(secrets), /TEST_CARD/);
-  });
-
-  test("is read-only", () => {
-    assert.throws(() => {
-      (secrets as Record<string, string>).TEST_CARD = "x";
-    }, TypeError);
-    assert.equal(secrets.TEST_CARD, "4242424242424242");
-  });
-
-  test("await does not treat it as a thenable", async () => {
-    assert.equal(await secrets, secrets);
-  });
-});

package/src/config/mask.test.ts

@@ -1,143 +0,0 @@
-import { afterEach, test } from "node:test";
-import { inspect } from "node:util";
-import assert from "node:assert/strict";
-import { isShortSecret, MASK, maskDeep, maskFormat, maskText, registerSecret, resetSecrets } from "./mask.js";
-
-afterEach(() => resetSecrets());
-
-test("nothing registered leaves text alone", () => {
-  assert.equal(maskText("card 4242"), "card 4242");
-});
-
-test("masks every occurrence of a long value", () => {
-  registerSecret("TEST_CARD", "4242424242424242");
-  assert.equal(maskText("fill 4242424242424242 then 4242424242424242x"), `fill ${MASK} then ${MASK}x`);
-});
-
-test("escapes regex characters", () => {
-  registerSecret("PW", "p@ss.w*rd+(1)");
-  assert.equal(maskText("pw=p@ss.w*rd+(1)!"), `pw=${MASK}!`);
-  assert.equal(maskText("p@ssXw*rd+(1)"), "p@ssXw*rd+(1)");
-});
-
-test("masks the longest secret first", () => {
-  registerSecret("SHORT", "secret");
-  registerSecret("LONG", "secret-and-more");
-  assert.equal(maskText("x secret-and-more y secret"), `x ${MASK} y ${MASK}`);
-});
-
-test("short values only match whole tokens", () => {
-  registerSecret("PIN", "12");
-  assert.equal(maskText("pin 12, step 12."), `pin ${MASK}, step ${MASK}.`);
-  assert.equal(maskText("2012 and a12b"), "2012 and a12b");
-  assert.equal(maskText("12"), MASK);
-});
-
-test("empty values are ignored", () => {
-  registerSecret("EMPTY", "");
-  assert.equal(maskText("anything"), "anything");
-});
-
-test("isShortSecret", () => {
-  assert.equal(isShortSecret("abc"), true);
-  assert.equal(isShortSecret("abcd"), false);
-  assert.equal(isShortSecret(""), false);
-});
-
-test("maskDeep masks strings in nested objects and arrays and returns a copy", () => {
-  registerSecret("TEST_CARD", "4242424242424242");
-  const result = {
-    message: "expected 4242424242424242",
-    expected: "4242424242424242",
-    duration: 12,
-    logs: [{ text: "typed 4242424242424242", timestamp: 1 }],
-  };
-  const masked = maskDeep(result);
-  assert.deepEqual(masked, {
-    message: `expected ${MASK}`,
-    expected: MASK,
-    duration: 12,
-    logs: [{ text: `typed ${MASK}`, timestamp: 1 }],
-  });
-  assert.equal(result.expected, "4242424242424242");
-});
-
-test("maskFormat masks the message and metadata of a log entry", () => {
-  registerSecret("TEST_CARD", "4242424242424242");
-  const info = maskFormat().transform({
-    level: "info",
-    message: "filled 4242424242424242",
-    meta: { value: "4242424242424242" },
-  }) as unknown as { message: string; meta: { value: string } };
-  assert.equal(info.message, `filled ${MASK}`);
-  assert.equal(info.meta.value, MASK);
-});
-
-class Wrapper {
-  constructor(public v: string) {}
-}
-
-test("maskDeep masks inside class instances, toJSON objects and null-prototype objects", () => {
-  registerSecret("TEST_CARD", "4242424242424242");
-  const input = new Wrapper("4242424242424242");
-  const out = maskDeep({ w: input, u: new URL("https://x.test/?c=4242424242424242") }) as unknown as {
-    w: { v: string };
-    u: string;
-  };
-  assert.deepEqual(out.w, { v: MASK });
-  assert.equal(out.u, `https://x.test/?c=${MASK}`);
-  assert.equal(input.v, "4242424242424242");
-
-  const bare = Object.create(null) as Record<string, string>;
-  bare.v = "4242424242424242";
-  assert.deepEqual(maskDeep({ bare }), { bare: { v: MASK } });
-  assert.equal(bare.v, "4242424242424242");
-});
-
-test("maskDeep masks an Error's name, message and stack", () => {
-  registerSecret("TEST_CARD", "4242424242424242");
-  const err = new Error("bad 4242424242424242");
-  const out = maskDeep({ err }) as unknown as { err: { name: string; message: string; stack: string } };
-  assert.equal(out.err.message, `bad ${MASK}`);
-  assert.ok(!out.err.stack.includes("4242424242424242"));
-  assert.equal(err.message, "bad 4242424242424242");
-});
-
-test("maskFormat masks class instances, URLs and errors in metadata", () => {
-  registerSecret("TEST_CARD", "4242424242424242");
-  const info = maskFormat().transform({
-    level: "info",
-    message: "m",
-    meta: { w: new Wrapper("4242424242424242"), u: new URL("https://x.test/4242424242424242"), e: new Error("4242424242424242") },
-  }) as unknown as { meta: unknown };
-  assert.ok(!JSON.stringify(info.meta).includes("4242424242424242"));
-  assert.ok(JSON.stringify(info.meta).includes(MASK));
-});
-
-test("circular structures do not throw and are masked elsewhere", () => {
-  registerSecret("TEST_CARD", "4242424242424242");
-  const circ: Record<string, unknown> = { card: "4242424242424242" };
-  circ.self = circ;
-  const out = maskDeep(circ) as { card: string; self: unknown };
-  assert.equal(out.card, MASK);
-  assert.equal(out.self, "[Circular]");
-  const info = maskFormat().transform({ level: "info", message: "m", meta: { circ } }) as unknown as {
-    meta: { circ: { card: string } };
-  };
-  assert.equal(info.meta.circ.card, MASK);
-});
-
-test("the same object twice (not circular) is masked both times", () => {
-  registerSecret("TEST_CARD", "4242424242424242");
-  const shared = { v: "4242424242424242" };
-  assert.deepEqual(maskDeep({ a: shared, b: shared }), { a: { v: MASK }, b: { v: MASK } });
-});
-
-test("escaped and encoded copies of a secret are masked", () => {
-  const secret = 'ab\\cd"ef gh';
-  registerSecret("PW", secret);
-  assert.equal(maskText(JSON.stringify(secret)), `"${MASK}"`);
-  assert.equal(maskText(inspect(secret)), `'${MASK}'`);
-  assert.equal(maskText(`q=${encodeURIComponent(secret)}`), `q=${MASK}`);
-  assert.equal(maskText(secret), MASK);
-});