@logtape/testing 2.2.0-dev.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024–2026 Hong Minhee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+<!-- deno-fmt-ignore-file -->
+
+Testing utilities for LogTape
+=============================
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+This package provides testing utilities for [LogTape].  It includes a log
+recorder that collects `LogRecord` values in memory and provides matcher-based
+assertions for category, level, rendered message, raw message, and structured
+properties.
+
+[JSR badge]: https://jsr.io/badges/@logtape/testing
+[JSR]: https://jsr.io/@logtape/testing
+[npm badge]: https://img.shields.io/npm/v/@logtape/testing?logo=npm
+[npm]: https://www.npmjs.com/package/@logtape/testing
+[LogTape]: https://logtape.org/
+
+
+Installation
+------------
+
+This package is available on [JSR] and [npm].  You can install it for various
+JavaScript runtimes and package managers:
+
+~~~~ sh
+deno add jsr:@logtape/testing  # for Deno
+npm  add     @logtape/testing  # for npm
+pnpm add     @logtape/testing  # for pnpm
+yarn add     @logtape/testing  # for Yarn
+bun  add     @logtape/testing  # for Bun
+~~~~
+
+
+Usage
+-----
+
+Use `createLogRecorder()` as a sink in tests:
+
+~~~~ typescript
+import { configure, getLogger, reset } from "@logtape/logtape";
+import { createLogRecorder } from "@logtape/testing";
+
+const recorder = createLogRecorder();
+
+try {
+  await configure({
+    sinks: { recorder: recorder.sink },
+    loggers: [
+      { category: ["my-lib"], lowestLevel: "debug", sinks: ["recorder"] },
+      { category: ["logtape", "meta"], sinks: [] },
+    ],
+  });
+
+  getLogger(["my-lib"]).info("User {userId} logged in.", {
+    userId: "u-123",
+  });
+
+  recorder.assertLogged({
+    category: ["my-lib"],
+    level: "info",
+    message: "User u-123 logged in.",
+    properties: { userId: "u-123" },
+  });
+} finally {
+  await reset();
+}
+~~~~
+
+The recorder also provides `records`, `clear()`, `take()`, `find()`,
+`filter()`, and `assertNotLogged()` for tests that need lower-level access.
+
+
+Docs
+----
+
+The docs of this package is available at
+<https://logtape.org/manual/testing>. For the API references, see
+<https://jsr.io/@logtape/testing>.

package/dist/mod.cjs

@@ -0,0 +1,214 @@
+
+//#region src/mod.ts
+/**
+* Creates a LogTape test recorder.
+*
+* @example
+* ```ts
+* import { configure, getLogger, reset } from "@logtape/logtape";
+* import { createLogRecorder } from "@logtape/testing";
+*
+* const recorder = createLogRecorder();
+*
+* try {
+*   await configure({
+*     sinks: { recorder: recorder.sink },
+*     loggers: [
+*       { category: ["my-lib"], lowestLevel: "debug", sinks: ["recorder"] },
+*     ],
+*   });
+*
+*   getLogger(["my-lib"]).info("User {userId} logged in.", {
+*     userId: "u-123",
+*   });
+*
+*   recorder.assertLogged({
+*     category: ["my-lib"],
+*     level: "info",
+*     message: "User u-123 logged in.",
+*     properties: { userId: "u-123" },
+*   });
+* } finally {
+*   await reset();
+* }
+* ```
+*
+* @returns A recorder with a sink and assertion helpers.
+* @since 2.2.0
+*/
+function createLogRecorder() {
+	const records = [];
+	const sink = (record) => {
+		records.push(record);
+	};
+	return {
+		sink,
+		get records() {
+			return records;
+		},
+		clear() {
+			records.length = 0;
+		},
+		take() {
+			return records.splice(0);
+		},
+		find(match) {
+			return records.find((record) => matchesLogRecord(record, match));
+		},
+		filter(match) {
+			return records.filter((record) => matchesLogRecord(record, match));
+		},
+		assertLogged(match) {
+			if (records.some((record) => matchesLogRecord(record, match))) return;
+			throw new Error([
+				"Expected a LogTape record matching:",
+				formatMatcher(match),
+				"",
+				`Recorded ${formatCount(records.length, "record")}:`,
+				formatRecords(records)
+			].join("\n"));
+		},
+		assertNotLogged(match) {
+			const matching = records.filter((record) => matchesLogRecord(record, match));
+			if (matching.length < 1) return;
+			throw new Error([
+				"Expected no LogTape record matching:",
+				formatMatcher(match),
+				"",
+				`Found ${formatCount(matching.length, "matching record")}:`,
+				formatRecords(matching)
+			].join("\n"));
+		}
+	};
+}
+function matchesLogRecord(record, match) {
+	if (match.category != null && !matchesCategory(record.category, match.category)) return false;
+	if (match.categoryPrefix != null && !matchesCategoryPrefix(record.category, match.categoryPrefix)) return false;
+	if (match.level != null && record.level !== match.level) return false;
+	if (match.message != null && !matchesMessage(renderMessage(record.message), record, match.message)) return false;
+	if (match.rawMessage != null && !matchesText(renderRawMessage(record.rawMessage), match.rawMessage)) return false;
+	if (match.properties != null && !matchesProperties(record.properties, record, match.properties)) return false;
+	if (match.predicate != null && !match.predicate(record)) return false;
+	return true;
+}
+function matchesCategory(category, expected) {
+	const joinedCategory = category.join(".");
+	if (expected instanceof RegExp) return testRegExp(expected, joinedCategory);
+	if (typeof expected === "string") return joinedCategory === expected;
+	const expectedCategory = parseCategory(expected);
+	return category.length === expectedCategory.length && category.every((part, index) => part === expectedCategory[index]);
+}
+function matchesCategoryPrefix(category, prefix) {
+	const expectedPrefix = parseCategory(prefix);
+	return expectedPrefix.length <= category.length && expectedPrefix.every((part, index) => part === category[index]);
+}
+function parseCategory(category) {
+	return typeof category === "string" ? category.split(".") : category;
+}
+function matchesMessage(renderedMessage, record, matcher) {
+	if (typeof matcher === "function") return matcher(record);
+	return matchesText(renderedMessage, matcher);
+}
+function matchesText(text, matcher) {
+	return typeof matcher === "string" ? text === matcher : testRegExp(matcher, text);
+}
+function matchesProperties(properties, record, matcher) {
+	if (typeof matcher === "function") return matcher(properties, record);
+	for (const key of Object.keys(matcher)) {
+		if (!Object.hasOwn(properties, key)) return false;
+		if (!Object.is(properties[key], matcher[key])) return false;
+	}
+	return true;
+}
+function testRegExp(pattern, text) {
+	const flags = pattern.flags;
+	const clone = new RegExp(pattern.source, flags);
+	clone.lastIndex = pattern.lastIndex;
+	return clone.test(text);
+}
+function renderRawMessage(rawMessage) {
+	return typeof rawMessage === "string" ? rawMessage : [...rawMessage].join("");
+}
+function renderMessage(message) {
+	let rendered = "";
+	for (const part of message) rendered += renderMessagePart(part);
+	return rendered;
+}
+function renderMessagePart(part) {
+	if (typeof part === "string") return part;
+	if (typeof part === "bigint") return `${part}n`;
+	if (part instanceof Error) return part.message;
+	if (part == null) return String(part);
+	if (typeof part === "object") try {
+		return JSON.stringify(part) ?? String(part);
+	} catch {
+		return String(part);
+	}
+	return String(part);
+}
+function formatMatcher(match) {
+	const lines = [];
+	if (match.category != null) lines.push(`  category: ${formatCategoryMatcher(match.category)}`);
+	if (match.categoryPrefix != null) lines.push(`  categoryPrefix: ${formatCategoryValue(parseCategory(match.categoryPrefix))}`);
+	if (match.level != null) lines.push(`  level: ${formatValue(match.level)}`);
+	if (match.message != null) lines.push(`  message: ${formatMessageMatcher(match.message)}`);
+	if (match.rawMessage != null) lines.push(`  rawMessage: ${formatTextMatcher(match.rawMessage)}`);
+	if (match.properties != null) lines.push(...formatPropertiesMatcher(match.properties));
+	if (match.predicate != null) lines.push("  predicate: <predicate>");
+	return lines.length < 1 ? "  <any record>" : lines.join("\n");
+}
+function formatCategoryMatcher(category) {
+	return category instanceof RegExp ? String(category) : typeof category === "string" ? formatValue(category) : formatCategoryValue(category);
+}
+function formatCategoryValue(category) {
+	return `[${category.map((part) => formatValue(part)).join(", ")}]`;
+}
+function formatMessageMatcher(matcher) {
+	return typeof matcher === "function" ? "<predicate>" : formatTextMatcher(matcher);
+}
+function formatTextMatcher(matcher) {
+	return typeof matcher === "string" ? formatValue(matcher) : String(matcher);
+}
+function formatPropertiesMatcher(matcher) {
+	if (typeof matcher === "function") return ["  properties: <predicate>"];
+	const lines = Object.keys(matcher).map((key) => `  properties.${key}: ${formatValue(matcher[key])}`);
+	return lines.length < 1 ? ["  properties: {}"] : lines;
+}
+function formatRecords(records) {
+	if (records.length < 1) return "  <none>";
+	const lines = records.slice(0, 3).map(formatRecord);
+	if (records.length > 3) lines.push(`  ... ${records.length - 3} more`);
+	return lines.join("\n");
+}
+function formatRecord(record) {
+	const category = formatCategory(record.category);
+	return `  [${record.level}] ${category}: ${renderMessage(record.message)}${formatProperties(record.properties)}`;
+}
+function formatCategory(category) {
+	return category.length < 1 ? "<root>" : category.join(".");
+}
+function formatProperties(properties) {
+	const entries = Object.keys(properties);
+	if (entries.length < 1) return "";
+	const summary = entries.slice(0, 3).map((key) => `${key}: ${formatValue(properties[key])}`);
+	if (entries.length > 3) summary.push(`... ${entries.length - 3} more`);
+	return ` {${summary.join(", ")}}`;
+}
+function formatCount(count, noun) {
+	return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function formatValue(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value === "symbol") return String(value);
+	if (value instanceof RegExp) return String(value);
+	if (value instanceof Error) return `${value.name}: ${value.message}`;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+
+//#endregion
+exports.createLogRecorder = createLogRecorder;

package/dist/mod.d.cts

@@ -0,0 +1,151 @@
+import { LogLevel, LogRecord, Sink } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * A predicate that matches log record properties.
+ *
+ * The first argument is the resolved properties object.  The second argument
+ * is the full log record for cases where the predicate needs category, level,
+ * or message context.
+ *
+ * @since 2.2.0
+ */
+type PropertyMatcher = (properties: Readonly<Record<string, unknown>>, record: LogRecord) => boolean;
+/**
+ * A matcher for records collected by a {@link LogRecorder}.
+ *
+ * Object property matching is shallow: every own string key in the matcher
+ * must exist on the record properties and have the same value according to
+ * `Object.is()`.  Use a {@link PropertyMatcher} when a test needs absence
+ * checks or deeper matching.
+ *
+ * @since 2.2.0
+ */
+interface LogRecordMatch {
+  /**
+   * Exact category matcher.  A string is matched against the dot-joined
+   * category, while an array is matched segment by segment.  A regular
+   * expression is tested against the dot-joined category.
+   */
+  readonly category?: string | readonly string[] | RegExp;
+  /**
+   * Category prefix matcher.  A string is split on dots, while an array is
+   * matched segment by segment.
+   */
+  readonly categoryPrefix?: string | readonly string[];
+  /**
+   * Exact severity level matcher.
+   */
+  readonly level?: LogLevel;
+  /**
+   * Rendered message matcher.  String and regular expression matchers are
+   * applied to the rendered message.  A predicate receives the full record.
+   */
+  readonly message?: string | RegExp | ((record: LogRecord) => boolean);
+  /**
+   * Raw message matcher.  A string record is matched directly.  A tagged
+   * template record is matched against the concatenated template strings.
+   */
+  readonly rawMessage?: string | RegExp;
+  /**
+   * Shallow property matcher or predicate.
+   */
+  readonly properties?: Readonly<Record<string, unknown>> | PropertyMatcher;
+  /**
+   * Full-record predicate for custom checks.
+   */
+  readonly predicate?: (record: LogRecord) => boolean;
+}
+/**
+ * A test recorder for LogTape records.
+ *
+ * @since 2.2.0
+ */
+interface LogRecorder {
+  /**
+   * A sink that appends each received record to {@link LogRecorder.records}.
+   */
+  readonly sink: Sink;
+  /**
+   * Records collected so far, in sink call order.
+   */
+  readonly records: readonly LogRecord[];
+  /**
+   * Removes all collected records.
+   */
+  clear(): void;
+  /**
+   * Returns collected records and clears the recorder.
+   */
+  take(): readonly LogRecord[];
+  /**
+   * Finds the first collected record matching the given matcher.
+   *
+   * @param match The matcher to apply.
+   * @returns The first matching record, or `undefined`.
+   */
+  find(match: LogRecordMatch): LogRecord | undefined;
+  /**
+   * Finds all collected records matching the given matcher.
+   *
+   * @param match The matcher to apply.
+   * @returns All matching records in collection order.
+   */
+  filter(match: LogRecordMatch): readonly LogRecord[];
+  /**
+   * Asserts that at least one collected record matches the given matcher.
+   *
+   * @param match The matcher to apply.
+   * @throws {Error} If no matching record exists.
+   */
+  assertLogged(match: LogRecordMatch): void;
+  /**
+   * Asserts that no collected record matches the given matcher.
+   *
+   * @param match The matcher to apply.
+   * @throws {Error} If a matching record exists.
+   */
+  assertNotLogged(match: LogRecordMatch): void;
+}
+/**
+ * Creates a LogTape test recorder.
+ *
+ * @example
+ * ```ts
+ * import { configure, getLogger, reset } from "@logtape/logtape";
+ * import { createLogRecorder } from "@logtape/testing";
+ *
+ * const recorder = createLogRecorder();
+ *
+ * try {
+ *   await configure({
+ *     sinks: { recorder: recorder.sink },
+ *     loggers: [
+ *       { category: ["my-lib"], lowestLevel: "debug", sinks: ["recorder"] },
+ *     ],
+ *   });
+ *
+ *   getLogger(["my-lib"]).info("User {userId} logged in.", {
+ *     userId: "u-123",
+ *   });
+ *
+ *   recorder.assertLogged({
+ *     category: ["my-lib"],
+ *     level: "info",
+ *     message: "User u-123 logged in.",
+ *     properties: { userId: "u-123" },
+ *   });
+ * } finally {
+ *   await reset();
+ * }
+ * ```
+ *
+ * @returns A recorder with a sink and assertion helpers.
+ * @since 2.2.0
+ */
+declare function createLogRecorder(): LogRecorder;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { LogRecordMatch, LogRecorder, PropertyMatcher, createLogRecorder };
+//# sourceMappingURL=mod.d.cts.map

package/dist/mod.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;AAEmB;AAanB;AAA+B,KAfnB,eAAA,GAemB,CAAA,UAAA,EAdjB,QAciB,CAdR,MAcQ,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,EAbrB,SAaqB,EAAA,GAAA,OAAA;;;;;;;;;;AAuCU;AAQxB,UA/CA,cAAA,CA+CW;EAAA;;;;;EA2BA,SAAG,QAAA,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA,GApEoB,MAoEpB;EAAS;;;;EAwBD,SAAA,cAAA,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA;EAuCvB;;;mBAxHG;;;;;8BAMW,mBAAmB;;;;;iCAMhB;;;;wBAKT,SAAS,2BAA2B;;;;gCAK5B;;;;;;;UAQf,WAAA;;;;iBAIA;;;;6BAKY;;;;;;;;mBAUV;;;;;;;cAQL,iBAAiB;;;;;;;gBAQf,0BAA0B;;;;;;;sBAQpB;;;;;;;yBAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCT,iBAAA,CAAA,GAAqB"}

package/dist/mod.d.ts

@@ -0,0 +1,151 @@
+import { LogLevel, LogRecord, Sink } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * A predicate that matches log record properties.
+ *
+ * The first argument is the resolved properties object.  The second argument
+ * is the full log record for cases where the predicate needs category, level,
+ * or message context.
+ *
+ * @since 2.2.0
+ */
+type PropertyMatcher = (properties: Readonly<Record<string, unknown>>, record: LogRecord) => boolean;
+/**
+ * A matcher for records collected by a {@link LogRecorder}.
+ *
+ * Object property matching is shallow: every own string key in the matcher
+ * must exist on the record properties and have the same value according to
+ * `Object.is()`.  Use a {@link PropertyMatcher} when a test needs absence
+ * checks or deeper matching.
+ *
+ * @since 2.2.0
+ */
+interface LogRecordMatch {
+  /**
+   * Exact category matcher.  A string is matched against the dot-joined
+   * category, while an array is matched segment by segment.  A regular
+   * expression is tested against the dot-joined category.
+   */
+  readonly category?: string | readonly string[] | RegExp;
+  /**
+   * Category prefix matcher.  A string is split on dots, while an array is
+   * matched segment by segment.
+   */
+  readonly categoryPrefix?: string | readonly string[];
+  /**
+   * Exact severity level matcher.
+   */
+  readonly level?: LogLevel;
+  /**
+   * Rendered message matcher.  String and regular expression matchers are
+   * applied to the rendered message.  A predicate receives the full record.
+   */
+  readonly message?: string | RegExp | ((record: LogRecord) => boolean);
+  /**
+   * Raw message matcher.  A string record is matched directly.  A tagged
+   * template record is matched against the concatenated template strings.
+   */
+  readonly rawMessage?: string | RegExp;
+  /**
+   * Shallow property matcher or predicate.
+   */
+  readonly properties?: Readonly<Record<string, unknown>> | PropertyMatcher;
+  /**
+   * Full-record predicate for custom checks.
+   */
+  readonly predicate?: (record: LogRecord) => boolean;
+}
+/**
+ * A test recorder for LogTape records.
+ *
+ * @since 2.2.0
+ */
+interface LogRecorder {
+  /**
+   * A sink that appends each received record to {@link LogRecorder.records}.
+   */
+  readonly sink: Sink;
+  /**
+   * Records collected so far, in sink call order.
+   */
+  readonly records: readonly LogRecord[];
+  /**
+   * Removes all collected records.
+   */
+  clear(): void;
+  /**
+   * Returns collected records and clears the recorder.
+   */
+  take(): readonly LogRecord[];
+  /**
+   * Finds the first collected record matching the given matcher.
+   *
+   * @param match The matcher to apply.
+   * @returns The first matching record, or `undefined`.
+   */
+  find(match: LogRecordMatch): LogRecord | undefined;
+  /**
+   * Finds all collected records matching the given matcher.
+   *
+   * @param match The matcher to apply.
+   * @returns All matching records in collection order.
+   */
+  filter(match: LogRecordMatch): readonly LogRecord[];
+  /**
+   * Asserts that at least one collected record matches the given matcher.
+   *
+   * @param match The matcher to apply.
+   * @throws {Error} If no matching record exists.
+   */
+  assertLogged(match: LogRecordMatch): void;
+  /**
+   * Asserts that no collected record matches the given matcher.
+   *
+   * @param match The matcher to apply.
+   * @throws {Error} If a matching record exists.
+   */
+  assertNotLogged(match: LogRecordMatch): void;
+}
+/**
+ * Creates a LogTape test recorder.
+ *
+ * @example
+ * ```ts
+ * import { configure, getLogger, reset } from "@logtape/logtape";
+ * import { createLogRecorder } from "@logtape/testing";
+ *
+ * const recorder = createLogRecorder();
+ *
+ * try {
+ *   await configure({
+ *     sinks: { recorder: recorder.sink },
+ *     loggers: [
+ *       { category: ["my-lib"], lowestLevel: "debug", sinks: ["recorder"] },
+ *     ],
+ *   });
+ *
+ *   getLogger(["my-lib"]).info("User {userId} logged in.", {
+ *     userId: "u-123",
+ *   });
+ *
+ *   recorder.assertLogged({
+ *     category: ["my-lib"],
+ *     level: "info",
+ *     message: "User u-123 logged in.",
+ *     properties: { userId: "u-123" },
+ *   });
+ * } finally {
+ *   await reset();
+ * }
+ * ```
+ *
+ * @returns A recorder with a sink and assertion helpers.
+ * @since 2.2.0
+ */
+declare function createLogRecorder(): LogRecorder;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { LogRecordMatch, LogRecorder, PropertyMatcher, createLogRecorder };
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;AAEmB;AAanB;AAA+B,KAfnB,eAAA,GAemB,CAAA,UAAA,EAdjB,QAciB,CAdR,MAcQ,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,EAbrB,SAaqB,EAAA,GAAA,OAAA;;;;;;;;;;AAuCU;AAQxB,UA/CA,cAAA,CA+CW;EAAA;;;;;EA2BA,SAAG,QAAA,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA,GApEoB,MAoEpB;EAAS;;;;EAwBD,SAAA,cAAA,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA;EAuCvB;;;mBAxHG;;;;;8BAMW,mBAAmB;;;;;iCAMhB;;;;wBAKT,SAAS,2BAA2B;;;;gCAK5B;;;;;;;UAQf,WAAA;;;;iBAIA;;;;6BAKY;;;;;;;;mBAUV;;;;;;;cAQL,iBAAiB;;;;;;;gBAQf,0BAA0B;;;;;;;sBAQpB;;;;;;;yBAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCT,iBAAA,CAAA,GAAqB"}

package/dist/mod.js

@@ -0,0 +1,214 @@
+//#region src/mod.ts
+/**
+* Creates a LogTape test recorder.
+*
+* @example
+* ```ts
+* import { configure, getLogger, reset } from "@logtape/logtape";
+* import { createLogRecorder } from "@logtape/testing";
+*
+* const recorder = createLogRecorder();
+*
+* try {
+*   await configure({
+*     sinks: { recorder: recorder.sink },
+*     loggers: [
+*       { category: ["my-lib"], lowestLevel: "debug", sinks: ["recorder"] },
+*     ],
+*   });
+*
+*   getLogger(["my-lib"]).info("User {userId} logged in.", {
+*     userId: "u-123",
+*   });
+*
+*   recorder.assertLogged({
+*     category: ["my-lib"],
+*     level: "info",
+*     message: "User u-123 logged in.",
+*     properties: { userId: "u-123" },
+*   });
+* } finally {
+*   await reset();
+* }
+* ```
+*
+* @returns A recorder with a sink and assertion helpers.
+* @since 2.2.0
+*/
+function createLogRecorder() {
+	const records = [];
+	const sink = (record) => {
+		records.push(record);
+	};
+	return {
+		sink,
+		get records() {
+			return records;
+		},
+		clear() {
+			records.length = 0;
+		},
+		take() {
+			return records.splice(0);
+		},
+		find(match) {
+			return records.find((record) => matchesLogRecord(record, match));
+		},
+		filter(match) {
+			return records.filter((record) => matchesLogRecord(record, match));
+		},
+		assertLogged(match) {
+			if (records.some((record) => matchesLogRecord(record, match))) return;
+			throw new Error([
+				"Expected a LogTape record matching:",
+				formatMatcher(match),
+				"",
+				`Recorded ${formatCount(records.length, "record")}:`,
+				formatRecords(records)
+			].join("\n"));
+		},
+		assertNotLogged(match) {
+			const matching = records.filter((record) => matchesLogRecord(record, match));
+			if (matching.length < 1) return;
+			throw new Error([
+				"Expected no LogTape record matching:",
+				formatMatcher(match),
+				"",
+				`Found ${formatCount(matching.length, "matching record")}:`,
+				formatRecords(matching)
+			].join("\n"));
+		}
+	};
+}
+function matchesLogRecord(record, match) {
+	if (match.category != null && !matchesCategory(record.category, match.category)) return false;
+	if (match.categoryPrefix != null && !matchesCategoryPrefix(record.category, match.categoryPrefix)) return false;
+	if (match.level != null && record.level !== match.level) return false;
+	if (match.message != null && !matchesMessage(renderMessage(record.message), record, match.message)) return false;
+	if (match.rawMessage != null && !matchesText(renderRawMessage(record.rawMessage), match.rawMessage)) return false;
+	if (match.properties != null && !matchesProperties(record.properties, record, match.properties)) return false;
+	if (match.predicate != null && !match.predicate(record)) return false;
+	return true;
+}
+function matchesCategory(category, expected) {
+	const joinedCategory = category.join(".");
+	if (expected instanceof RegExp) return testRegExp(expected, joinedCategory);
+	if (typeof expected === "string") return joinedCategory === expected;
+	const expectedCategory = parseCategory(expected);
+	return category.length === expectedCategory.length && category.every((part, index) => part === expectedCategory[index]);
+}
+function matchesCategoryPrefix(category, prefix) {
+	const expectedPrefix = parseCategory(prefix);
+	return expectedPrefix.length <= category.length && expectedPrefix.every((part, index) => part === category[index]);
+}
+function parseCategory(category) {
+	return typeof category === "string" ? category.split(".") : category;
+}
+function matchesMessage(renderedMessage, record, matcher) {
+	if (typeof matcher === "function") return matcher(record);
+	return matchesText(renderedMessage, matcher);
+}
+function matchesText(text, matcher) {
+	return typeof matcher === "string" ? text === matcher : testRegExp(matcher, text);
+}
+function matchesProperties(properties, record, matcher) {
+	if (typeof matcher === "function") return matcher(properties, record);
+	for (const key of Object.keys(matcher)) {
+		if (!Object.hasOwn(properties, key)) return false;
+		if (!Object.is(properties[key], matcher[key])) return false;
+	}
+	return true;
+}
+function testRegExp(pattern, text) {
+	const flags = pattern.flags;
+	const clone = new RegExp(pattern.source, flags);
+	clone.lastIndex = pattern.lastIndex;
+	return clone.test(text);
+}
+function renderRawMessage(rawMessage) {
+	return typeof rawMessage === "string" ? rawMessage : [...rawMessage].join("");
+}
+function renderMessage(message) {
+	let rendered = "";
+	for (const part of message) rendered += renderMessagePart(part);
+	return rendered;
+}
+function renderMessagePart(part) {
+	if (typeof part === "string") return part;
+	if (typeof part === "bigint") return `${part}n`;
+	if (part instanceof Error) return part.message;
+	if (part == null) return String(part);
+	if (typeof part === "object") try {
+		return JSON.stringify(part) ?? String(part);
+	} catch {
+		return String(part);
+	}
+	return String(part);
+}
+function formatMatcher(match) {
+	const lines = [];
+	if (match.category != null) lines.push(`  category: ${formatCategoryMatcher(match.category)}`);
+	if (match.categoryPrefix != null) lines.push(`  categoryPrefix: ${formatCategoryValue(parseCategory(match.categoryPrefix))}`);
+	if (match.level != null) lines.push(`  level: ${formatValue(match.level)}`);
+	if (match.message != null) lines.push(`  message: ${formatMessageMatcher(match.message)}`);
+	if (match.rawMessage != null) lines.push(`  rawMessage: ${formatTextMatcher(match.rawMessage)}`);
+	if (match.properties != null) lines.push(...formatPropertiesMatcher(match.properties));
+	if (match.predicate != null) lines.push("  predicate: <predicate>");
+	return lines.length < 1 ? "  <any record>" : lines.join("\n");
+}
+function formatCategoryMatcher(category) {
+	return category instanceof RegExp ? String(category) : typeof category === "string" ? formatValue(category) : formatCategoryValue(category);
+}
+function formatCategoryValue(category) {
+	return `[${category.map((part) => formatValue(part)).join(", ")}]`;
+}
+function formatMessageMatcher(matcher) {
+	return typeof matcher === "function" ? "<predicate>" : formatTextMatcher(matcher);
+}
+function formatTextMatcher(matcher) {
+	return typeof matcher === "string" ? formatValue(matcher) : String(matcher);
+}
+function formatPropertiesMatcher(matcher) {
+	if (typeof matcher === "function") return ["  properties: <predicate>"];
+	const lines = Object.keys(matcher).map((key) => `  properties.${key}: ${formatValue(matcher[key])}`);
+	return lines.length < 1 ? ["  properties: {}"] : lines;
+}
+function formatRecords(records) {
+	if (records.length < 1) return "  <none>";
+	const lines = records.slice(0, 3).map(formatRecord);
+	if (records.length > 3) lines.push(`  ... ${records.length - 3} more`);
+	return lines.join("\n");
+}
+function formatRecord(record) {
+	const category = formatCategory(record.category);
+	return `  [${record.level}] ${category}: ${renderMessage(record.message)}${formatProperties(record.properties)}`;
+}
+function formatCategory(category) {
+	return category.length < 1 ? "<root>" : category.join(".");
+}
+function formatProperties(properties) {
+	const entries = Object.keys(properties);
+	if (entries.length < 1) return "";
+	const summary = entries.slice(0, 3).map((key) => `${key}: ${formatValue(properties[key])}`);
+	if (entries.length > 3) summary.push(`... ${entries.length - 3} more`);
+	return ` {${summary.join(", ")}}`;
+}
+function formatCount(count, noun) {
+	return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function formatValue(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value === "symbol") return String(value);
+	if (value instanceof RegExp) return String(value);
+	if (value instanceof Error) return `${value.name}: ${value.message}`;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+
+//#endregion
+export { createLogRecorder };
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","names":["records: LogRecord[]","sink: Sink","record: LogRecord","match: LogRecordMatch","category: readonly string[]","expected: string | readonly string[] | RegExp","prefix: string | readonly string[]","category: string | readonly string[]","renderedMessage: string","matcher: string | RegExp | ((record: LogRecord) => boolean)","text: string","matcher: string | RegExp","properties: Readonly<Record<string, unknown>>","matcher: Readonly<Record<string, unknown>> | PropertyMatcher","pattern: RegExp","rawMessage: string | TemplateStringsArray","message: readonly unknown[]","part: unknown","lines: string[]","category: string | readonly string[] | RegExp","records: readonly LogRecord[]","count: number","noun: string","value: unknown"],"sources":["../src/mod.ts"],"sourcesContent":["import type { LogLevel, LogRecord, Sink } from \"@logtape/logtape\";\n\n/**\n * A predicate that matches log record properties.\n *\n * The first argument is the resolved properties object.  The second argument\n * is the full log record for cases where the predicate needs category, level,\n * or message context.\n *\n * @since 2.2.0\n */\nexport type PropertyMatcher = (\n  properties: Readonly<Record<string, unknown>>,\n  record: LogRecord,\n) => boolean;\n\n/**\n * A matcher for records collected by a {@link LogRecorder}.\n *\n * Object property matching is shallow: every own string key in the matcher\n * must exist on the record properties and have the same value according to\n * `Object.is()`.  Use a {@link PropertyMatcher} when a test needs absence\n * checks or deeper matching.\n *\n * @since 2.2.0\n */\nexport interface LogRecordMatch {\n  /**\n   * Exact category matcher.  A string is matched against the dot-joined\n   * category, while an array is matched segment by segment.  A regular\n   * expression is tested against the dot-joined category.\n   */\n  readonly category?: string | readonly string[] | RegExp;\n\n  /**\n   * Category prefix matcher.  A string is split on dots, while an array is\n   * matched segment by segment.\n   */\n  readonly categoryPrefix?: string | readonly string[];\n\n  /**\n   * Exact severity level matcher.\n   */\n  readonly level?: LogLevel;\n\n  /**\n   * Rendered message matcher.  String and regular expression matchers are\n   * applied to the rendered message.  A predicate receives the full record.\n   */\n  readonly message?: string | RegExp | ((record: LogRecord) => boolean);\n\n  /**\n   * Raw message matcher.  A string record is matched directly.  A tagged\n   * template record is matched against the concatenated template strings.\n   */\n  readonly rawMessage?: string | RegExp;\n\n  /**\n   * Shallow property matcher or predicate.\n   */\n  readonly properties?: Readonly<Record<string, unknown>> | PropertyMatcher;\n\n  /**\n   * Full-record predicate for custom checks.\n   */\n  readonly predicate?: (record: LogRecord) => boolean;\n}\n\n/**\n * A test recorder for LogTape records.\n *\n * @since 2.2.0\n */\nexport interface LogRecorder {\n  /**\n   * A sink that appends each received record to {@link LogRecorder.records}.\n   */\n  readonly sink: Sink;\n\n  /**\n   * Records collected so far, in sink call order.\n   */\n  readonly records: readonly LogRecord[];\n\n  /**\n   * Removes all collected records.\n   */\n  clear(): void;\n\n  /**\n   * Returns collected records and clears the recorder.\n   */\n  take(): readonly LogRecord[];\n\n  /**\n   * Finds the first collected record matching the given matcher.\n   *\n   * @param match The matcher to apply.\n   * @returns The first matching record, or `undefined`.\n   */\n  find(match: LogRecordMatch): LogRecord | undefined;\n\n  /**\n   * Finds all collected records matching the given matcher.\n   *\n   * @param match The matcher to apply.\n   * @returns All matching records in collection order.\n   */\n  filter(match: LogRecordMatch): readonly LogRecord[];\n\n  /**\n   * Asserts that at least one collected record matches the given matcher.\n   *\n   * @param match The matcher to apply.\n   * @throws {Error} If no matching record exists.\n   */\n  assertLogged(match: LogRecordMatch): void;\n\n  /**\n   * Asserts that no collected record matches the given matcher.\n   *\n   * @param match The matcher to apply.\n   * @throws {Error} If a matching record exists.\n   */\n  assertNotLogged(match: LogRecordMatch): void;\n}\n\n/**\n * Creates a LogTape test recorder.\n *\n * @example\n * ```ts\n * import { configure, getLogger, reset } from \"@logtape/logtape\";\n * import { createLogRecorder } from \"@logtape/testing\";\n *\n * const recorder = createLogRecorder();\n *\n * try {\n *   await configure({\n *     sinks: { recorder: recorder.sink },\n *     loggers: [\n *       { category: [\"my-lib\"], lowestLevel: \"debug\", sinks: [\"recorder\"] },\n *     ],\n *   });\n *\n *   getLogger([\"my-lib\"]).info(\"User {userId} logged in.\", {\n *     userId: \"u-123\",\n *   });\n *\n *   recorder.assertLogged({\n *     category: [\"my-lib\"],\n *     level: \"info\",\n *     message: \"User u-123 logged in.\",\n *     properties: { userId: \"u-123\" },\n *   });\n * } finally {\n *   await reset();\n * }\n * ```\n *\n * @returns A recorder with a sink and assertion helpers.\n * @since 2.2.0\n */\nexport function createLogRecorder(): LogRecorder {\n  const records: LogRecord[] = [];\n  const sink: Sink = (record: LogRecord): void => {\n    records.push(record);\n  };\n\n  return {\n    sink,\n    get records(): readonly LogRecord[] {\n      return records;\n    },\n    clear(): void {\n      records.length = 0;\n    },\n    take(): readonly LogRecord[] {\n      return records.splice(0);\n    },\n    find(match: LogRecordMatch): LogRecord | undefined {\n      return records.find((record) => matchesLogRecord(record, match));\n    },\n    filter(match: LogRecordMatch): readonly LogRecord[] {\n      return records.filter((record) => matchesLogRecord(record, match));\n    },\n    assertLogged(match: LogRecordMatch): void {\n      if (records.some((record) => matchesLogRecord(record, match))) return;\n\n      throw new Error(\n        [\n          \"Expected a LogTape record matching:\",\n          formatMatcher(match),\n          \"\",\n          `Recorded ${formatCount(records.length, \"record\")}:`,\n          formatRecords(records),\n        ].join(\"\\n\"),\n      );\n    },\n    assertNotLogged(match: LogRecordMatch): void {\n      const matching = records.filter((record) =>\n        matchesLogRecord(record, match)\n      );\n      if (matching.length < 1) return;\n\n      throw new Error(\n        [\n          \"Expected no LogTape record matching:\",\n          formatMatcher(match),\n          \"\",\n          `Found ${formatCount(matching.length, \"matching record\")}:`,\n          formatRecords(matching),\n        ].join(\"\\n\"),\n      );\n    },\n  };\n}\n\nfunction matchesLogRecord(record: LogRecord, match: LogRecordMatch): boolean {\n  if (\n    match.category != null &&\n    !matchesCategory(record.category, match.category)\n  ) {\n    return false;\n  }\n  if (\n    match.categoryPrefix != null &&\n    !matchesCategoryPrefix(record.category, match.categoryPrefix)\n  ) {\n    return false;\n  }\n  if (match.level != null && record.level !== match.level) return false;\n  if (\n    match.message != null &&\n    !matchesMessage(renderMessage(record.message), record, match.message)\n  ) {\n    return false;\n  }\n  if (\n    match.rawMessage != null &&\n    !matchesText(renderRawMessage(record.rawMessage), match.rawMessage)\n  ) {\n    return false;\n  }\n  if (\n    match.properties != null &&\n    !matchesProperties(record.properties, record, match.properties)\n  ) {\n    return false;\n  }\n  if (match.predicate != null && !match.predicate(record)) return false;\n  return true;\n}\n\nfunction matchesCategory(\n  category: readonly string[],\n  expected: string | readonly string[] | RegExp,\n): boolean {\n  const joinedCategory = category.join(\".\");\n  if (expected instanceof RegExp) {\n    return testRegExp(expected, joinedCategory);\n  }\n  if (typeof expected === \"string\") {\n    return joinedCategory === expected;\n  }\n  const expectedCategory = parseCategory(expected);\n  return category.length === expectedCategory.length &&\n    category.every((part, index) => part === expectedCategory[index]);\n}\n\nfunction matchesCategoryPrefix(\n  category: readonly string[],\n  prefix: string | readonly string[],\n): boolean {\n  const expectedPrefix = parseCategory(prefix);\n  return expectedPrefix.length <= category.length &&\n    expectedPrefix.every((part, index) => part === category[index]);\n}\n\nfunction parseCategory(\n  category: string | readonly string[],\n): readonly string[] {\n  return typeof category === \"string\" ? category.split(\".\") : category;\n}\n\nfunction matchesMessage(\n  renderedMessage: string,\n  record: LogRecord,\n  matcher: string | RegExp | ((record: LogRecord) => boolean),\n): boolean {\n  if (typeof matcher === \"function\") return matcher(record);\n  return matchesText(renderedMessage, matcher);\n}\n\nfunction matchesText(text: string, matcher: string | RegExp): boolean {\n  return typeof matcher === \"string\"\n    ? text === matcher\n    : testRegExp(matcher, text);\n}\n\nfunction matchesProperties(\n  properties: Readonly<Record<string, unknown>>,\n  record: LogRecord,\n  matcher: Readonly<Record<string, unknown>> | PropertyMatcher,\n): boolean {\n  if (typeof matcher === \"function\") return matcher(properties, record);\n  for (const key of Object.keys(matcher)) {\n    if (!Object.hasOwn(properties, key)) return false;\n    if (!Object.is(properties[key], matcher[key])) return false;\n  }\n  return true;\n}\n\nfunction testRegExp(pattern: RegExp, text: string): boolean {\n  const flags = pattern.flags;\n  const clone = new RegExp(pattern.source, flags);\n  clone.lastIndex = pattern.lastIndex;\n  return clone.test(text);\n}\n\nfunction renderRawMessage(rawMessage: string | TemplateStringsArray): string {\n  return typeof rawMessage === \"string\" ? rawMessage : [...rawMessage].join(\"\");\n}\n\nfunction renderMessage(message: readonly unknown[]): string {\n  let rendered = \"\";\n  for (const part of message) {\n    rendered += renderMessagePart(part);\n  }\n  return rendered;\n}\n\nfunction renderMessagePart(part: unknown): string {\n  if (typeof part === \"string\") return part;\n  if (typeof part === \"bigint\") return `${part}n`;\n  if (part instanceof Error) return part.message;\n  if (part == null) return String(part);\n  if (typeof part === \"object\") {\n    try {\n      return JSON.stringify(part) ?? String(part);\n    } catch {\n      return String(part);\n    }\n  }\n  return String(part);\n}\n\nfunction formatMatcher(match: LogRecordMatch): string {\n  const lines: string[] = [];\n  if (match.category != null) {\n    lines.push(`  category: ${formatCategoryMatcher(match.category)}`);\n  }\n  if (match.categoryPrefix != null) {\n    lines.push(\n      `  categoryPrefix: ${\n        formatCategoryValue(parseCategory(match.categoryPrefix))\n      }`,\n    );\n  }\n  if (match.level != null) lines.push(`  level: ${formatValue(match.level)}`);\n  if (match.message != null) {\n    lines.push(`  message: ${formatMessageMatcher(match.message)}`);\n  }\n  if (match.rawMessage != null) {\n    lines.push(`  rawMessage: ${formatTextMatcher(match.rawMessage)}`);\n  }\n  if (match.properties != null) {\n    lines.push(...formatPropertiesMatcher(match.properties));\n  }\n  if (match.predicate != null) lines.push(\"  predicate: <predicate>\");\n  return lines.length < 1 ? \"  <any record>\" : lines.join(\"\\n\");\n}\n\nfunction formatCategoryMatcher(\n  category: string | readonly string[] | RegExp,\n): string {\n  return category instanceof RegExp\n    ? String(category)\n    : typeof category === \"string\"\n    ? formatValue(category)\n    : formatCategoryValue(category);\n}\n\nfunction formatCategoryValue(category: readonly string[]): string {\n  return `[${category.map((part) => formatValue(part)).join(\", \")}]`;\n}\n\nfunction formatMessageMatcher(\n  matcher: string | RegExp | ((record: LogRecord) => boolean),\n): string {\n  return typeof matcher === \"function\" ? \"<predicate>\" : formatTextMatcher(\n    matcher,\n  );\n}\n\nfunction formatTextMatcher(matcher: string | RegExp): string {\n  return typeof matcher === \"string\" ? formatValue(matcher) : String(matcher);\n}\n\nfunction formatPropertiesMatcher(\n  matcher: Readonly<Record<string, unknown>> | PropertyMatcher,\n): string[] {\n  if (typeof matcher === \"function\") return [\"  properties: <predicate>\"];\n  const lines = Object.keys(matcher).map((key) =>\n    `  properties.${key}: ${formatValue(matcher[key])}`\n  );\n  return lines.length < 1 ? [\"  properties: {}\"] : lines;\n}\n\nfunction formatRecords(records: readonly LogRecord[]): string {\n  if (records.length < 1) return \"  <none>\";\n  const lines = records.slice(0, 3).map(formatRecord);\n  if (records.length > 3) {\n    lines.push(`  ... ${records.length - 3} more`);\n  }\n  return lines.join(\"\\n\");\n}\n\nfunction formatRecord(record: LogRecord): string {\n  const category = formatCategory(record.category);\n  return `  [${record.level}] ${category}: ${renderMessage(record.message)}${\n    formatProperties(record.properties)\n  }`;\n}\n\nfunction formatCategory(category: readonly string[]): string {\n  return category.length < 1 ? \"<root>\" : category.join(\".\");\n}\n\nfunction formatProperties(\n  properties: Readonly<Record<string, unknown>>,\n): string {\n  const entries = Object.keys(properties);\n  if (entries.length < 1) return \"\";\n  const summary = entries.slice(0, 3).map((key) =>\n    `${key}: ${formatValue(properties[key])}`\n  );\n  if (entries.length > 3) summary.push(`... ${entries.length - 3} more`);\n  return ` {${summary.join(\", \")}}`;\n}\n\nfunction formatCount(count: number, noun: string): string {\n  return `${count} ${noun}${count === 1 ? \"\" : \"s\"}`;\n}\n\nfunction formatValue(value: unknown): string {\n  if (typeof value === \"string\") return JSON.stringify(value);\n  if (typeof value === \"bigint\") return `${value}n`;\n  if (typeof value === \"symbol\") return String(value);\n  if (value instanceof RegExp) return String(value);\n  if (value instanceof Error) {\n    return `${value.name}: ${value.message}`;\n  }\n  try {\n    return JSON.stringify(value) ?? String(value);\n  } catch {\n    return String(value);\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@logtape/testing",
+  "version": "2.2.0-dev.0",
+  "description": "Testing utilities for collecting and asserting LogTape records",
+  "keywords": [
+    "logging",
+    "log",
+    "logger",
+    "logtape",
+    "testing",
+    "test"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Hong Minhee",
+    "email": "hong@minhee.org",
+    "url": "https://hongminhee.org/"
+  },
+  "homepage": "https://logtape.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dahlia/logtape.git",
+    "directory": "packages/testing/"
+  },
+  "bugs": {
+    "url": "https://github.com/dahlia/logtape/issues"
+  },
+  "funding": [
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "module": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
+  "types": "./dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts"
+      },
+      "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist/"
+  ],
+  "peerDependencies": {
+    "@logtape/logtape": "^2.2.0"
+  },
+  "devDependencies": {
+    "tsdown": "^0.12.7",
+    "typescript": "^5.8.3",
+    "@logtape/redaction": "^2.2.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test",
+    "test:deno": "deno test",
+    "test-all": "tsdown && node --experimental-transform-types --test && bun test && deno test"
+  }
+}