@logtape/testing 2.3.0-dev.815 → 2.3.0-dev.818

package/README.md

@@ -9,7 +9,8 @@ Testing utilities for LogTape
 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.
+properties.  It also includes a failure log reporter that buffers records while
+a test callback runs and reports them only when the callback fails.
 
 [JSR badge]: https://jsr.io/badges/@logtape/testing
 [JSR]: https://jsr.io/@logtape/testing
@@ -40,7 +41,7 @@ Use `createLogRecorder()` as a sink in tests:
 
 ~~~~ typescript
 import { configure, getLogger, reset } from "@logtape/logtape";
-import { createLogRecorder } from "@logtape/testing";
+import { createLogRecorder } from "@logtape/testing/recorder";
 
 const recorder = createLogRecorder();
 
@@ -77,6 +78,24 @@ that need lower-level access.  Most property values are compared with
 matcher values match string property values.  Rendered message matching uses
 the same value rendering as LogTape's default text formatter.
 
+Use `createFailureLogReporter()` when logs are useful only after a test fails:
+
+~~~~ typescript
+import { createFailureLogReporter } from "@logtape/testing/reporter";
+
+const reporter = createFailureLogReporter({
+  lowestLevel: "debug",
+});
+
+test("case", reporter.wrap(async () => {
+  // Logs emitted here are reported only if this callback throws.
+}));
+~~~~
+
+The root `@logtape/testing` entry point re-exports both utilities for
+compatibility, but new code can import `@logtape/testing/recorder` or
+`@logtape/testing/reporter` to depend on only the relevant API surface.
+
 
 Docs
 ----

package/dist/mod.cjs

@@ -1,326 +1,5 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+const require_recorder = require('./recorder.cjs');
+const require_reporter = require('./reporter.cjs');
 
-//#region src/mod.ts
-const messageFormatter = (0, __logtape_logtape.getTextFormatter)({
-	format: ({ message }) => message,
-	lineEnding: "lf",
-	timestamp: "none"
-});
-/**
-* 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: 123,
-*   });
-*
-*   recorder.assertLogged({
-*     category: ["my-lib"],
-*     level: "info",
-*     message: "User 123 logged in.",
-*     properties: { userId: 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(materializeLogRecord(record));
-	};
-	return {
-		sink,
-		get records() {
-			return records.slice();
-		},
-		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 materializeLogRecord(record) {
-	const message = record.message;
-	const rawMessage = record.rawMessage;
-	const descriptors = Object.getOwnPropertyDescriptors(record);
-	if (!hasStringAccessorDescriptor(descriptors)) return record;
-	const messageDescriptor = descriptors.message;
-	const rawMessageDescriptor = descriptors.rawMessage;
-	const snapshotDescriptors = Object.create(null);
-	for (const key of Reflect.ownKeys(descriptors)) {
-		if (isLogRecordKey(key)) continue;
-		const descriptor = descriptors[key];
-		if (descriptor == null) continue;
-		snapshotDescriptors[key] = isDataDescriptor(descriptor) ? descriptor : materializedDescriptor(Reflect.get(record, key), descriptor);
-	}
-	Object.assign(snapshotDescriptors, {
-		category: materializedDescriptor(record.category, descriptors.category),
-		level: materializedDescriptor(record.level, descriptors.level),
-		message: materializedDescriptor(message, messageDescriptor),
-		rawMessage: materializedDescriptor(rawMessage, rawMessageDescriptor),
-		timestamp: materializedDescriptor(record.timestamp, descriptors.timestamp),
-		properties: materializedDescriptor(record.properties, descriptors.properties)
-	});
-	return Object.defineProperties(Object.create(Object.getPrototypeOf(record)), snapshotDescriptors);
-}
-function hasStringAccessorDescriptor(descriptors) {
-	for (const key of Object.getOwnPropertyNames(descriptors)) {
-		const descriptor = descriptors[key];
-		if (descriptor != null && !isDataDescriptor(descriptor)) return true;
-	}
-	return false;
-}
-function isDataDescriptor(descriptor) {
-	return descriptor != null && "value" in descriptor;
-}
-function isLogRecordKey(key) {
-	return key === "category" || key === "level" || key === "message" || key === "rawMessage" || key === "timestamp" || key === "properties";
-}
-function materializedDescriptor(value, descriptor) {
-	return {
-		configurable: descriptor?.configurable ?? true,
-		enumerable: descriptor?.enumerable ?? true,
-		value,
-		writable: isDataDescriptor(descriptor) ? descriptor.writable : true
-	};
-}
-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(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) {
-	if (typeof category !== "string") return category;
-	return category === "" ? [] : category.split(".");
-}
-function matchesMessage(record, matcher) {
-	if (typeof matcher === "function") return matcher(record);
-	return matchesText(renderMessage(record), matcher);
-}
-function matchesText(text, matcher) {
-	return typeof matcher === "string" ? text === matcher : testRegExp(matcher, text);
-}
-function matchesProperties(properties, record, matcher) {
-	const props = properties ?? {};
-	if (typeof matcher === "function") return matcher(props, record);
-	for (const key of Object.keys(matcher)) {
-		if (!Object.prototype.hasOwnProperty.call(props, key)) return false;
-		if (!matchesPropertyValue(props[key], matcher[key])) return false;
-	}
-	return true;
-}
-function matchesPropertyValue(actual, expected) {
-	if (actual instanceof Date && expected instanceof Date) return Object.is(actual.getTime(), expected.getTime());
-	if (typeof actual === "string" && expected instanceof RegExp) return testRegExp(expected, actual);
-	return Object.is(actual, expected);
-}
-function testRegExp(pattern, text) {
-	if (!pattern.global && !pattern.sticky) return pattern.test(text);
-	const clone = new RegExp(pattern.source, pattern.flags);
-	return clone.test(text);
-}
-function renderRawMessage(rawMessage) {
-	return typeof rawMessage === "string" ? rawMessage : rawMessage.join("");
-}
-function renderMessage(record) {
-	return messageFormatter(record).slice(0, -1);
-}
-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}: ${formatPropertyValue(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}: ${formatMessage(record)}${formatProperties(record.properties)}`;
-}
-function formatMessage(record) {
-	try {
-		return renderMessage(record);
-	} catch (error) {
-		return formatAccessError(error);
-	}
-}
-function formatCategory(category) {
-	return category.length < 1 ? "<root>" : category.join(".");
-}
-function formatProperties(properties) {
-	const props = properties ?? {};
-	const entries = Object.keys(props);
-	if (entries.length < 1) return "";
-	const summary = entries.slice(0, 3).map((key) => `${key}: ${formatPropertyValue(props, key)}`);
-	if (entries.length > 3) summary.push(`... ${entries.length - 3} more`);
-	return ` {${summary.join(", ")}}`;
-}
-function formatPropertyValue(properties, key) {
-	try {
-		return formatValue(properties[key]);
-	} catch (error) {
-		return formatAccessError(error);
-	}
-}
-function formatAccessError(error) {
-	return `<error: ${error instanceof Error ? error.message : safeString(error)}>`;
-}
-function formatCount(count, noun) {
-	return `${count} ${noun}${count === 1 ? "" : "s"}`;
-}
-function formatValue(value) {
-	if (typeof value === "string") return JSON.stringify(value);
-	if (typeof value === "number" && !Number.isFinite(value)) return String(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}`;
-	if (value instanceof Map) return formatMap(value);
-	if (value instanceof Set) return formatSet(value);
-	try {
-		return safeJsonStringify(value) ?? safeString(value);
-	} catch {
-		return safeString(value);
-	}
-}
-function formatMap(value) {
-	const label = `Map(${value.size})`;
-	try {
-		const contents = formatMapContents(value);
-		return `${label} ${safeJsonStringify(contents) ?? safeString(contents)}`;
-	} catch {
-		return label;
-	}
-}
-function formatSet(value) {
-	const label = `Set(${value.size})`;
-	try {
-		const contents = Array.from(value);
-		return `${label} ${safeJsonStringify(contents) ?? safeString(contents)}`;
-	} catch {
-		return label;
-	}
-}
-function safeJsonStringify(value) {
-	const ancestors = [];
-	return JSON.stringify(value, function(_key, item) {
-		if (typeof item === "bigint") return `${item}n`;
-		if (item instanceof RegExp) return String(item);
-		if (item instanceof Error) return `${item.name}: ${item.message}`;
-		if (typeof item === "object" && item != null) {
-			while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) ancestors.pop();
-			if (ancestors.includes(item)) return "[Circular]";
-			ancestors.push(item);
-			if (item instanceof Map) return formatMapContents(item);
-			if (item instanceof Set) return Array.from(item);
-		}
-		return item;
-	});
-}
-function formatMapContents(value) {
-	const entries = Array.from(value, ([key, entryValue]) => [safeString(key), entryValue]);
-	const keys = entries.map(([key]) => key);
-	const uniqueKeys = new Set(keys);
-	return uniqueKeys.size === keys.length ? Object.fromEntries(entries) : entries;
-}
-function safeString(value) {
-	try {
-		return String(value);
-	} catch {
-		return Object.prototype.toString.call(value);
-	}
-}
-
-//#endregion
-exports.createLogRecorder = createLogRecorder;
+exports.createFailureLogReporter = require_reporter.createFailureLogReporter;
+exports.createLogRecorder = require_recorder.createLogRecorder;

package/dist/mod.d.cts

@@ -1,153 +1,3 @@
-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 match by value.  Most values are
- * compared with `Object.is()`, `Date` values are compared by timestamp, and
- * regular expression matcher values match string property values.  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, using the same value rendering as
-   * LogTape's default text formatter.  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;
-  /**
-   * A snapshot of 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: 123,
- *   });
- *
- *   recorder.assertLogged({
- *     category: ["my-lib"],
- *     level: "info",
- *     message: "User 123 logged in.",
- *     properties: { userId: 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
+import { LogRecordMatch, LogRecorder, PropertyMatcher, createLogRecorder } from "./recorder.cjs";
+import { FailureLogReportMode, FailureLogReporter, FailureLogReporterOptions, createFailureLogReporter } from "./reporter.cjs";
+export { FailureLogReportMode, FailureLogReporter, FailureLogReporterOptions, LogRecordMatch, LogRecorder, PropertyMatcher, createFailureLogReporter, createLogRecorder };

package/dist/mod.d.ts

@@ -1,153 +1,3 @@
-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 match by value.  Most values are
- * compared with `Object.is()`, `Date` values are compared by timestamp, and
- * regular expression matcher values match string property values.  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, using the same value rendering as
-   * LogTape's default text formatter.  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;
-  /**
-   * A snapshot of 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: 123,
- *   });
- *
- *   recorder.assertLogged({
- *     category: ["my-lib"],
- *     level: "info",
- *     message: "User 123 logged in.",
- *     properties: { userId: 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
+import { LogRecordMatch, LogRecorder, PropertyMatcher, createLogRecorder } from "./recorder.js";
+import { FailureLogReportMode, FailureLogReporter, FailureLogReporterOptions, createFailureLogReporter } from "./reporter.js";
+export { FailureLogReportMode, FailureLogReporter, FailureLogReporterOptions, LogRecordMatch, LogRecorder, PropertyMatcher, createFailureLogReporter, createLogRecorder };