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

package/dist/reporter.cjs

@@ -0,0 +1,71 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_snapshot = require('./snapshot.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/reporter.ts
+/**
+* Creates a failure log reporter for tests.
+*
+* The reporter uses LogTape's scoped configuration support.  The process-wide
+* configuration must already include `Config.contextLocalStorage`, but the
+* reporter does not mutate global logger routing while a wrapped callback
+* runs.
+*
+* @example
+* ```ts
+* 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.
+* }));
+* ```
+*
+* @param options Reporter options.
+* @returns A failure log reporter.
+* @since 2.3.0
+*/
+function createFailureLogReporter(options = {}) {
+	const mode = options.mode ?? "on-failure";
+	const lowestLevel = options.lowestLevel ?? "info";
+	const outputSink = options.sink ?? (0, __logtape_logtape.getConsoleSink)({ formatter: options.formatter });
+	async function run(callback) {
+		const records = [];
+		const bufferSink = (record) => {
+			records.push(require_snapshot.materializeLogRecord(record));
+		};
+		let result;
+		try {
+			result = await (0, __logtape_logtape.withConfig)({
+				sinks: { failureLogReporter: bufferSink },
+				loggers: [{
+					category: [],
+					lowestLevel,
+					parentSinks: "override",
+					sinks: ["failureLogReporter"]
+				}]
+			}, callback);
+		} catch (error) {
+			if (mode !== "never") try {
+				flushRecords(records, outputSink);
+			} catch {}
+			throw error;
+		}
+		if (mode === "always") flushRecords(records, outputSink);
+		return result;
+	}
+	function wrap(callback) {
+		return (...args) => run(() => callback(...args));
+	}
+	return {
+		run,
+		wrap
+	};
+}
+function flushRecords(records, sink) {
+	for (const record of records) sink(record);
+}
+
+//#endregion
+exports.createFailureLogReporter = createFailureLogReporter;

package/dist/reporter.d.cts

@@ -0,0 +1,88 @@
+import { LogLevel, Sink, TextFormatter } from "@logtape/logtape";
+
+//#region src/reporter.d.ts
+
+/**
+ * Controls when buffered records are reported by a
+ * {@link FailureLogReporter}.
+ *
+ * @since 2.3.0
+ */
+type FailureLogReportMode = "on-failure" | "always" | "never";
+/**
+ * Options for {@link createFailureLogReporter}.
+ *
+ * @since 2.3.0
+ */
+interface FailureLogReporterOptions {
+  /**
+   * When to report buffered records.  Defaults to `"on-failure"`.
+   */
+  readonly mode?: FailureLogReportMode;
+  /**
+   * The lowest severity level collected by the reporter's scoped
+   * configuration.  Defaults to `"info"`.
+   */
+  readonly lowestLevel?: LogLevel;
+  /**
+   * The sink that receives buffered records when the reporter flushes.
+   * Defaults to a console sink.
+   */
+  readonly sink?: Sink;
+  /**
+   * The text formatter used by the default console sink.
+   */
+  readonly formatter?: TextFormatter;
+}
+/**
+ * A reporter that buffers LogTape records while a test callback runs and
+ * reports them depending on the configured mode.
+ *
+ * @since 2.3.0
+ */
+interface FailureLogReporter {
+  /**
+   * Wraps a callback so matching LogTape records are reported according to the
+   * configured mode.
+   *
+   * @param callback The test callback to wrap.
+   * @returns An async callback with the same parameters.
+   */
+  wrap<TArgs extends readonly unknown[], TResult>(callback: (...args: TArgs) => TResult): (...args: TArgs) => Promise<Awaited<TResult>>;
+  /**
+   * Runs a callback and reports matching LogTape records according to the
+   * configured mode.
+   *
+   * @param callback The callback to run.
+   * @returns The callback result.
+   */
+  run<TResult>(callback: () => TResult): Promise<Awaited<TResult>>;
+}
+/**
+ * Creates a failure log reporter for tests.
+ *
+ * The reporter uses LogTape's scoped configuration support.  The process-wide
+ * configuration must already include `Config.contextLocalStorage`, but the
+ * reporter does not mutate global logger routing while a wrapped callback
+ * runs.
+ *
+ * @example
+ * ```ts
+ * 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.
+ * }));
+ * ```
+ *
+ * @param options Reporter options.
+ * @returns A failure log reporter.
+ * @since 2.3.0
+ */
+declare function createFailureLogReporter(options?: FailureLogReporterOptions): FailureLogReporter;
+//# sourceMappingURL=reporter.d.ts.map
+//#endregion
+export { FailureLogReportMode, FailureLogReporter, FailureLogReporterOptions, createFailureLogReporter };
+//# sourceMappingURL=reporter.d.cts.map

package/dist/reporter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.cts","names":[],"sources":["../src/reporter.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;AAOA;;;AAUyB,KAjBb,oBAAA,GAiBa,YAAA,GAAA,QAAA,GAAA,OAAA;;;AAWW;AASpC;;AASwB,UAvCP,yBAAA,CAuCO;EAAK;;;EACmB,SAAf,IAAA,CAAA,EApCf,oBAoCe;EAAO;;;;EASgB,SAAf,WAAA,CAAA,EAvChB,QAuCgB;EAAO;AA0BhD;;;EACyC,SACtC,IAAA,CAAA,EA7De,IA6Df;EAAkB;;;uBAxDE;;;;;;;;UASN,kBAAA;;;;;;;;sEASO,UAAU,oBACnB,UAAU,QAAQ,QAAQ;;;;;;;;+BASV,UAAU,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BzC,wBAAA,WACL,4BACR"}

package/dist/reporter.d.ts

@@ -0,0 +1,88 @@
+import { LogLevel, Sink, TextFormatter } from "@logtape/logtape";
+
+//#region src/reporter.d.ts
+
+/**
+ * Controls when buffered records are reported by a
+ * {@link FailureLogReporter}.
+ *
+ * @since 2.3.0
+ */
+type FailureLogReportMode = "on-failure" | "always" | "never";
+/**
+ * Options for {@link createFailureLogReporter}.
+ *
+ * @since 2.3.0
+ */
+interface FailureLogReporterOptions {
+  /**
+   * When to report buffered records.  Defaults to `"on-failure"`.
+   */
+  readonly mode?: FailureLogReportMode;
+  /**
+   * The lowest severity level collected by the reporter's scoped
+   * configuration.  Defaults to `"info"`.
+   */
+  readonly lowestLevel?: LogLevel;
+  /**
+   * The sink that receives buffered records when the reporter flushes.
+   * Defaults to a console sink.
+   */
+  readonly sink?: Sink;
+  /**
+   * The text formatter used by the default console sink.
+   */
+  readonly formatter?: TextFormatter;
+}
+/**
+ * A reporter that buffers LogTape records while a test callback runs and
+ * reports them depending on the configured mode.
+ *
+ * @since 2.3.0
+ */
+interface FailureLogReporter {
+  /**
+   * Wraps a callback so matching LogTape records are reported according to the
+   * configured mode.
+   *
+   * @param callback The test callback to wrap.
+   * @returns An async callback with the same parameters.
+   */
+  wrap<TArgs extends readonly unknown[], TResult>(callback: (...args: TArgs) => TResult): (...args: TArgs) => Promise<Awaited<TResult>>;
+  /**
+   * Runs a callback and reports matching LogTape records according to the
+   * configured mode.
+   *
+   * @param callback The callback to run.
+   * @returns The callback result.
+   */
+  run<TResult>(callback: () => TResult): Promise<Awaited<TResult>>;
+}
+/**
+ * Creates a failure log reporter for tests.
+ *
+ * The reporter uses LogTape's scoped configuration support.  The process-wide
+ * configuration must already include `Config.contextLocalStorage`, but the
+ * reporter does not mutate global logger routing while a wrapped callback
+ * runs.
+ *
+ * @example
+ * ```ts
+ * 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.
+ * }));
+ * ```
+ *
+ * @param options Reporter options.
+ * @returns A failure log reporter.
+ * @since 2.3.0
+ */
+declare function createFailureLogReporter(options?: FailureLogReporterOptions): FailureLogReporter;
+//# sourceMappingURL=reporter.d.ts.map
+//#endregion
+export { FailureLogReportMode, FailureLogReporter, FailureLogReporterOptions, createFailureLogReporter };
+//# sourceMappingURL=reporter.d.ts.map

package/dist/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","names":[],"sources":["../src/reporter.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;AAOA;;;AAUyB,KAjBb,oBAAA,GAiBa,YAAA,GAAA,QAAA,GAAA,OAAA;;;AAWW;AASpC;;AASwB,UAvCP,yBAAA,CAuCO;EAAK;;;EACmB,SAAf,IAAA,CAAA,EApCf,oBAoCe;EAAO;;;;EASgB,SAAf,WAAA,CAAA,EAvChB,QAuCgB;EAAO;AA0BhD;;;EACyC,SACtC,IAAA,CAAA,EA7De,IA6Df;EAAkB;;;uBAxDE;;;;;;;;UASN,kBAAA;;;;;;;;sEASO,UAAU,oBACnB,UAAU,QAAQ,QAAQ;;;;;;;;+BASV,UAAU,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BzC,wBAAA,WACL,4BACR"}

package/dist/reporter.js

@@ -0,0 +1,71 @@
+import { materializeLogRecord } from "./snapshot.js";
+import { getConsoleSink, withConfig } from "@logtape/logtape";
+
+//#region src/reporter.ts
+/**
+* Creates a failure log reporter for tests.
+*
+* The reporter uses LogTape's scoped configuration support.  The process-wide
+* configuration must already include `Config.contextLocalStorage`, but the
+* reporter does not mutate global logger routing while a wrapped callback
+* runs.
+*
+* @example
+* ```ts
+* 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.
+* }));
+* ```
+*
+* @param options Reporter options.
+* @returns A failure log reporter.
+* @since 2.3.0
+*/
+function createFailureLogReporter(options = {}) {
+	const mode = options.mode ?? "on-failure";
+	const lowestLevel = options.lowestLevel ?? "info";
+	const outputSink = options.sink ?? getConsoleSink({ formatter: options.formatter });
+	async function run(callback) {
+		const records = [];
+		const bufferSink = (record) => {
+			records.push(materializeLogRecord(record));
+		};
+		let result;
+		try {
+			result = await withConfig({
+				sinks: { failureLogReporter: bufferSink },
+				loggers: [{
+					category: [],
+					lowestLevel,
+					parentSinks: "override",
+					sinks: ["failureLogReporter"]
+				}]
+			}, callback);
+		} catch (error) {
+			if (mode !== "never") try {
+				flushRecords(records, outputSink);
+			} catch {}
+			throw error;
+		}
+		if (mode === "always") flushRecords(records, outputSink);
+		return result;
+	}
+	function wrap(callback) {
+		return (...args) => run(() => callback(...args));
+	}
+	return {
+		run,
+		wrap
+	};
+}
+function flushRecords(records, sink) {
+	for (const record of records) sink(record);
+}
+
+//#endregion
+export { createFailureLogReporter };
+//# sourceMappingURL=reporter.js.map

package/dist/reporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.js","names":["options: FailureLogReporterOptions","callback: () => TResult","records: LogRecord[]","bufferSink: Sink","record: LogRecord","result: Awaited<TResult>","callback: (...args: TArgs) => TResult","records: readonly LogRecord[]","sink: Sink"],"sources":["../src/reporter.ts"],"sourcesContent":["import {\n  getConsoleSink,\n  type LogLevel,\n  type LogRecord,\n  type Sink,\n  type TextFormatter,\n  withConfig,\n} from \"@logtape/logtape\";\n\nimport { materializeLogRecord } from \"./snapshot.ts\";\n\n/**\n * Controls when buffered records are reported by a\n * {@link FailureLogReporter}.\n *\n * @since 2.3.0\n */\nexport type FailureLogReportMode = \"on-failure\" | \"always\" | \"never\";\n\n/**\n * Options for {@link createFailureLogReporter}.\n *\n * @since 2.3.0\n */\nexport interface FailureLogReporterOptions {\n  /**\n   * When to report buffered records.  Defaults to `\"on-failure\"`.\n   */\n  readonly mode?: FailureLogReportMode;\n\n  /**\n   * The lowest severity level collected by the reporter's scoped\n   * configuration.  Defaults to `\"info\"`.\n   */\n  readonly lowestLevel?: LogLevel;\n\n  /**\n   * The sink that receives buffered records when the reporter flushes.\n   * Defaults to a console sink.\n   */\n  readonly sink?: Sink;\n\n  /**\n   * The text formatter used by the default console sink.\n   */\n  readonly formatter?: TextFormatter;\n}\n\n/**\n * A reporter that buffers LogTape records while a test callback runs and\n * reports them depending on the configured mode.\n *\n * @since 2.3.0\n */\nexport interface FailureLogReporter {\n  /**\n   * Wraps a callback so matching LogTape records are reported according to the\n   * configured mode.\n   *\n   * @param callback The test callback to wrap.\n   * @returns An async callback with the same parameters.\n   */\n  wrap<TArgs extends readonly unknown[], TResult>(\n    callback: (...args: TArgs) => TResult,\n  ): (...args: TArgs) => Promise<Awaited<TResult>>;\n\n  /**\n   * Runs a callback and reports matching LogTape records according to the\n   * configured mode.\n   *\n   * @param callback The callback to run.\n   * @returns The callback result.\n   */\n  run<TResult>(callback: () => TResult): Promise<Awaited<TResult>>;\n}\n\n/**\n * Creates a failure log reporter for tests.\n *\n * The reporter uses LogTape's scoped configuration support.  The process-wide\n * configuration must already include `Config.contextLocalStorage`, but the\n * reporter does not mutate global logger routing while a wrapped callback\n * runs.\n *\n * @example\n * ```ts\n * import { createFailureLogReporter } from \"@logtape/testing/reporter\";\n *\n * const reporter = createFailureLogReporter({ lowestLevel: \"debug\" });\n *\n * test(\"case\", reporter.wrap(async () => {\n *   // Logs emitted here are reported only if this callback throws.\n * }));\n * ```\n *\n * @param options Reporter options.\n * @returns A failure log reporter.\n * @since 2.3.0\n */\nexport function createFailureLogReporter(\n  options: FailureLogReporterOptions = {},\n): FailureLogReporter {\n  const mode = options.mode ?? \"on-failure\";\n  const lowestLevel = options.lowestLevel ?? \"info\";\n  const outputSink = options.sink ?? getConsoleSink({\n    formatter: options.formatter,\n  });\n\n  async function run<TResult>(\n    callback: () => TResult,\n  ): Promise<Awaited<TResult>> {\n    const records: LogRecord[] = [];\n    const bufferSink: Sink = (record: LogRecord): void => {\n      records.push(materializeLogRecord(record));\n    };\n\n    let result: Awaited<TResult>;\n    try {\n      result = await withConfig({\n        sinks: { failureLogReporter: bufferSink },\n        loggers: [{\n          category: [],\n          lowestLevel,\n          parentSinks: \"override\",\n          sinks: [\"failureLogReporter\"],\n        }],\n      }, callback);\n    } catch (error) {\n      if (mode !== \"never\") {\n        try {\n          flushRecords(records, outputSink);\n        } catch {\n          // Keep the test runner focused on the original assertion error.\n        }\n      }\n      throw error;\n    }\n\n    if (mode === \"always\") flushRecords(records, outputSink);\n    return result;\n  }\n\n  function wrap<TArgs extends readonly unknown[], TResult>(\n    callback: (...args: TArgs) => TResult,\n  ): (...args: TArgs) => Promise<Awaited<TResult>> {\n    return (...args: TArgs) => run(() => callback(...args));\n  }\n\n  return {\n    run,\n    wrap,\n  };\n}\n\nfunction flushRecords(\n  records: readonly LogRecord[],\n  sink: Sink,\n): void {\n  for (const record of records) sink(record);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGA,SAAgB,yBACdA,UAAqC,CAAE,GACnB;CACpB,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,cAAc,QAAQ,eAAe;CAC3C,MAAM,aAAa,QAAQ,QAAQ,eAAe,EAChD,WAAW,QAAQ,UACpB,EAAC;CAEF,eAAe,IACbC,UAC2B;EAC3B,MAAMC,UAAuB,CAAE;EAC/B,MAAMC,aAAmB,CAACC,WAA4B;AACpD,WAAQ,KAAK,qBAAqB,OAAO,CAAC;EAC3C;EAED,IAAIC;AACJ,MAAI;AACF,YAAS,MAAM,WAAW;IACxB,OAAO,EAAE,oBAAoB,WAAY;IACzC,SAAS,CAAC;KACR,UAAU,CAAE;KACZ;KACA,aAAa;KACb,OAAO,CAAC,oBAAqB;IAC9B,CAAC;GACH,GAAE,SAAS;EACb,SAAQ,OAAO;AACd,OAAI,SAAS,QACX,KAAI;AACF,iBAAa,SAAS,WAAW;GAClC,QAAO,CAEP;AAEH,SAAM;EACP;AAED,MAAI,SAAS,SAAU,cAAa,SAAS,WAAW;AACxD,SAAO;CACR;CAED,SAAS,KACPC,UAC+C;AAC/C,SAAO,CAAC,GAAG,SAAgB,IAAI,MAAM,SAAS,GAAG,KAAK,CAAC;CACxD;AAED,QAAO;EACL;EACA;CACD;AACF;AAED,SAAS,aACPC,SACAC,MACM;AACN,MAAK,MAAM,UAAU,QAAS,MAAK,OAAO;AAC3C"}

package/dist/snapshot.cjs

@@ -0,0 +1,50 @@
+
+//#region src/snapshot.ts
+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
+	};
+}
+
+//#endregion
+exports.materializeLogRecord = materializeLogRecord;

package/dist/snapshot.js

@@ -0,0 +1,50 @@
+//#region src/snapshot.ts
+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
+	};
+}
+
+//#endregion
+export { materializeLogRecord };
+//# sourceMappingURL=snapshot.js.map

package/dist/snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.js","names":["record: LogRecord","descriptors: PropertyDescriptorMap","descriptor: PropertyDescriptor | undefined","key: PropertyKey","value: unknown"],"sources":["../src/snapshot.ts"],"sourcesContent":["import type { LogRecord } from \"@logtape/logtape\";\n\nexport function materializeLogRecord(record: LogRecord): LogRecord {\n  const message = record.message;\n  const rawMessage = record.rawMessage;\n  const descriptors = Object.getOwnPropertyDescriptors(\n    record,\n  ) as PropertyDescriptorMap;\n  if (!hasStringAccessorDescriptor(descriptors)) {\n    return record;\n  }\n  const messageDescriptor = descriptors.message;\n  const rawMessageDescriptor = descriptors.rawMessage;\n  const snapshotDescriptors = Object.create(null) as PropertyDescriptorMap;\n  for (const key of Reflect.ownKeys(descriptors)) {\n    if (isLogRecordKey(key)) continue;\n    const descriptor = descriptors[key];\n    if (descriptor == null) continue;\n    snapshotDescriptors[key] = isDataDescriptor(descriptor)\n      ? descriptor\n      : materializedDescriptor(Reflect.get(record, key), descriptor);\n  }\n  Object.assign(snapshotDescriptors, {\n    category: materializedDescriptor(record.category, descriptors.category),\n    level: materializedDescriptor(record.level, descriptors.level),\n    message: materializedDescriptor(message, messageDescriptor),\n    rawMessage: materializedDescriptor(rawMessage, rawMessageDescriptor),\n    timestamp: materializedDescriptor(record.timestamp, descriptors.timestamp),\n    properties: materializedDescriptor(\n      record.properties,\n      descriptors.properties,\n    ),\n  });\n  return Object.defineProperties(\n    Object.create(Object.getPrototypeOf(record)),\n    snapshotDescriptors,\n  ) as LogRecord;\n}\n\nfunction hasStringAccessorDescriptor(\n  descriptors: PropertyDescriptorMap,\n): boolean {\n  for (const key of Object.getOwnPropertyNames(descriptors)) {\n    const descriptor = descriptors[key];\n    if (descriptor != null && !isDataDescriptor(descriptor)) return true;\n  }\n  return false;\n}\n\nfunction isDataDescriptor(\n  descriptor: PropertyDescriptor | undefined,\n): descriptor is PropertyDescriptor & { readonly value: unknown } {\n  return descriptor != null && \"value\" in descriptor;\n}\n\nfunction isLogRecordKey(key: PropertyKey): key is keyof LogRecord {\n  return key === \"category\" ||\n    key === \"level\" ||\n    key === \"message\" ||\n    key === \"rawMessage\" ||\n    key === \"timestamp\" ||\n    key === \"properties\";\n}\n\nfunction materializedDescriptor(\n  value: unknown,\n  descriptor: PropertyDescriptor | undefined,\n): PropertyDescriptor {\n  return {\n    configurable: descriptor?.configurable ?? true,\n    enumerable: descriptor?.enumerable ?? true,\n    value,\n    writable: isDataDescriptor(descriptor) ? descriptor.writable : true,\n  };\n}\n"],"mappings":";AAEA,SAAgB,qBAAqBA,QAA8B;CACjE,MAAM,UAAU,OAAO;CACvB,MAAM,aAAa,OAAO;CAC1B,MAAM,cAAc,OAAO,0BACzB,OACD;AACD,MAAK,4BAA4B,YAAY,CAC3C,QAAO;CAET,MAAM,oBAAoB,YAAY;CACtC,MAAM,uBAAuB,YAAY;CACzC,MAAM,sBAAsB,OAAO,OAAO,KAAK;AAC/C,MAAK,MAAM,OAAO,QAAQ,QAAQ,YAAY,EAAE;AAC9C,MAAI,eAAe,IAAI,CAAE;EACzB,MAAM,aAAa,YAAY;AAC/B,MAAI,cAAc,KAAM;AACxB,sBAAoB,OAAO,iBAAiB,WAAW,GACnD,aACA,uBAAuB,QAAQ,IAAI,QAAQ,IAAI,EAAE,WAAW;CACjE;AACD,QAAO,OAAO,qBAAqB;EACjC,UAAU,uBAAuB,OAAO,UAAU,YAAY,SAAS;EACvE,OAAO,uBAAuB,OAAO,OAAO,YAAY,MAAM;EAC9D,SAAS,uBAAuB,SAAS,kBAAkB;EAC3D,YAAY,uBAAuB,YAAY,qBAAqB;EACpE,WAAW,uBAAuB,OAAO,WAAW,YAAY,UAAU;EAC1E,YAAY,uBACV,OAAO,YACP,YAAY,WACb;CACF,EAAC;AACF,QAAO,OAAO,iBACZ,OAAO,OAAO,OAAO,eAAe,OAAO,CAAC,EAC5C,oBACD;AACF;AAED,SAAS,4BACPC,aACS;AACT,MAAK,MAAM,OAAO,OAAO,oBAAoB,YAAY,EAAE;EACzD,MAAM,aAAa,YAAY;AAC/B,MAAI,cAAc,SAAS,iBAAiB,WAAW,CAAE,QAAO;CACjE;AACD,QAAO;AACR;AAED,SAAS,iBACPC,YACgE;AAChE,QAAO,cAAc,QAAQ,WAAW;AACzC;AAED,SAAS,eAAeC,KAA0C;AAChE,QAAO,QAAQ,cACb,QAAQ,WACR,QAAQ,aACR,QAAQ,gBACR,QAAQ,eACR,QAAQ;AACX;AAED,SAAS,uBACPC,OACAF,YACoB;AACpB,QAAO;EACL,cAAc,YAAY,gBAAgB;EAC1C,YAAY,YAAY,cAAc;EACtC;EACA,UAAU,iBAAiB,WAAW,GAAG,WAAW,WAAW;CAChE;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/testing",
-  "version": "2.3.0-dev.815+6c913282",
+  "version": "2.3.0-dev.818+d457bb3c",
   "description": "Testing utilities for collecting and asserting LogTape records",
   "keywords": [
     "logging",
@@ -41,6 +41,22 @@
       "import": "./dist/mod.js",
       "require": "./dist/mod.cjs"
     },
+    "./recorder": {
+      "types": {
+        "import": "./dist/recorder.d.ts",
+        "require": "./dist/recorder.d.cts"
+      },
+      "import": "./dist/recorder.js",
+      "require": "./dist/recorder.cjs"
+    },
+    "./reporter": {
+      "types": {
+        "import": "./dist/reporter.d.ts",
+        "require": "./dist/reporter.d.cts"
+      },
+      "import": "./dist/reporter.js",
+      "require": "./dist/reporter.cjs"
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,
@@ -48,12 +64,12 @@
     "dist/"
   ],
   "peerDependencies": {
-    "@logtape/logtape": "^2.3.0-dev.815+6c913282"
+    "@logtape/logtape": "^2.3.0-dev.818+d457bb3c"
   },
   "devDependencies": {
     "tsdown": "^0.12.7",
     "typescript": "^5.8.3",
-    "@logtape/redaction": "^2.3.0-dev.815+6c913282"
+    "@logtape/redaction": "^2.3.0-dev.818+d457bb3c"
   },
   "scripts": {
     "build": "tsdown",

package/dist/mod.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;AAuBA;;;;;AAEmB;AAcnB;AAA+B,KAhBnB,eAAA,GAgBmB,CAAA,UAAA,EAfjB,QAeiB,CAfR,MAeQ,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,EAdrB,SAcqB,EAAA,GAAA,OAAA;;;;;;;;;;AAwCU;AAQzC;AAA4B,UAhDX,cAAA,CAgDW;EAAA;;;;;EA2BY,SAQxB,QAAA,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA,GA7EmC,MA6EnC;EAAc;;;AAgBS;EAuCvB,SAAA,cAAiB,CAAA,EAAA,MAAI,GAAA,SAAW,MAAA,EAAA;;;;mBAzH7B;;;;;;8BAOW,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.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;AAuBA;;;;;AAEmB;AAcnB;AAA+B,KAhBnB,eAAA,GAgBmB,CAAA,UAAA,EAfjB,QAeiB,CAfR,MAeQ,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,EAdrB,SAcqB,EAAA,GAAA,OAAA;;;;;;;;;;AAwCU;AAQzC;AAA4B,UAhDX,cAAA,CAgDW;EAAA;;;;;EA2BY,SAQxB,QAAA,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA,GA7EmC,MA6EnC;EAAc;;;AAgBS;EAuCvB,SAAA,cAAiB,CAAA,EAAA,MAAI,GAAA,SAAW,MAAA,EAAA;;;;mBAzH7B;;;;;;8BAOW,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.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.js","names":["messageFormatter: TextFormatter","records: LogRecord[]","sink: Sink","record: LogRecord","match: LogRecordMatch","descriptors: PropertyDescriptorMap","descriptor: PropertyDescriptor | undefined","key: PropertyKey","value: unknown","category: readonly string[]","expected: string | readonly string[] | RegExp","prefix: string | readonly string[]","category: string | readonly string[]","matcher: string | RegExp | ((record: LogRecord) => boolean)","text: string","matcher: string | RegExp","properties: Readonly<Record<string, unknown>> | null | undefined","matcher: Readonly<Record<string, unknown>> | PropertyMatcher","props: Readonly<Record<string, unknown>>","actual: unknown","expected: unknown","pattern: RegExp","rawMessage: string | TemplateStringsArray","lines: string[]","category: string | readonly string[] | RegExp","records: readonly LogRecord[]","properties: Readonly<Record<string, unknown>>","key: string","error: unknown","count: number","noun: string","value: ReadonlyMap<unknown, unknown>","value: ReadonlySet<unknown>","ancestors: object[]","_key: string","item: unknown"],"sources":["../src/mod.ts"],"sourcesContent":["import {\n  getTextFormatter,\n  type LogLevel,\n  type LogRecord,\n  type Sink,\n  type TextFormatter,\n} from \"@logtape/logtape\";\n\nconst messageFormatter: TextFormatter = getTextFormatter({\n  format: ({ message }) => message,\n  lineEnding: \"lf\",\n  timestamp: \"none\",\n});\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 match by value.  Most values are\n * compared with `Object.is()`, `Date` values are compared by timestamp, and\n * regular expression matcher values match string property values.  Use a\n * {@link PropertyMatcher} when a test needs absence 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, using the same value rendering as\n   * LogTape's default text formatter.  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   * A snapshot of 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: 123,\n *   });\n *\n *   recorder.assertLogged({\n *     category: [\"my-lib\"],\n *     level: \"info\",\n *     message: \"User 123 logged in.\",\n *     properties: { userId: 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(materializeLogRecord(record));\n  };\n\n  return {\n    sink,\n    get records(): readonly LogRecord[] {\n      return records.slice();\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 materializeLogRecord(record: LogRecord): LogRecord {\n  const message = record.message;\n  const rawMessage = record.rawMessage;\n  const descriptors = Object.getOwnPropertyDescriptors(\n    record,\n  ) as PropertyDescriptorMap;\n  if (!hasStringAccessorDescriptor(descriptors)) {\n    return record;\n  }\n  const messageDescriptor = descriptors.message;\n  const rawMessageDescriptor = descriptors.rawMessage;\n  const snapshotDescriptors = Object.create(null) as PropertyDescriptorMap;\n  for (const key of Reflect.ownKeys(descriptors)) {\n    if (isLogRecordKey(key)) continue;\n    const descriptor = descriptors[key];\n    if (descriptor == null) continue;\n    snapshotDescriptors[key] = isDataDescriptor(descriptor)\n      ? descriptor\n      : materializedDescriptor(Reflect.get(record, key), descriptor);\n  }\n  Object.assign(snapshotDescriptors, {\n    category: materializedDescriptor(record.category, descriptors.category),\n    level: materializedDescriptor(record.level, descriptors.level),\n    message: materializedDescriptor(message, messageDescriptor),\n    rawMessage: materializedDescriptor(rawMessage, rawMessageDescriptor),\n    timestamp: materializedDescriptor(record.timestamp, descriptors.timestamp),\n    properties: materializedDescriptor(\n      record.properties,\n      descriptors.properties,\n    ),\n  });\n  return Object.defineProperties(\n    Object.create(Object.getPrototypeOf(record)),\n    snapshotDescriptors,\n  ) as LogRecord;\n}\n\nfunction hasStringAccessorDescriptor(\n  descriptors: PropertyDescriptorMap,\n): boolean {\n  for (const key of Object.getOwnPropertyNames(descriptors)) {\n    const descriptor = descriptors[key];\n    if (descriptor != null && !isDataDescriptor(descriptor)) return true;\n  }\n  return false;\n}\n\nfunction isDataDescriptor(\n  descriptor: PropertyDescriptor | undefined,\n): descriptor is PropertyDescriptor & { readonly value: unknown } {\n  return descriptor != null && \"value\" in descriptor;\n}\n\nfunction isLogRecordKey(key: PropertyKey): key is keyof LogRecord {\n  return key === \"category\" ||\n    key === \"level\" ||\n    key === \"message\" ||\n    key === \"rawMessage\" ||\n    key === \"timestamp\" ||\n    key === \"properties\";\n}\n\nfunction materializedDescriptor(\n  value: unknown,\n  descriptor: PropertyDescriptor | undefined,\n): PropertyDescriptor {\n  return {\n    configurable: descriptor?.configurable ?? true,\n    enumerable: descriptor?.enumerable ?? true,\n    value,\n    writable: isDataDescriptor(descriptor) ? descriptor.writable : true,\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(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  if (typeof category !== \"string\") return category;\n  return category === \"\" ? [] : category.split(\".\");\n}\n\nfunction matchesMessage(\n  record: LogRecord,\n  matcher: string | RegExp | ((record: LogRecord) => boolean),\n): boolean {\n  if (typeof matcher === \"function\") return matcher(record);\n  return matchesText(renderMessage(record), 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>> | null | undefined,\n  record: LogRecord,\n  matcher: Readonly<Record<string, unknown>> | PropertyMatcher,\n): boolean {\n  const props: Readonly<Record<string, unknown>> = properties ?? {};\n  if (typeof matcher === \"function\") return matcher(props, record);\n  for (const key of Object.keys(matcher)) {\n    if (!Object.prototype.hasOwnProperty.call(props, key)) return false;\n    if (!matchesPropertyValue(props[key], matcher[key])) return false;\n  }\n  return true;\n}\n\nfunction matchesPropertyValue(actual: unknown, expected: unknown): boolean {\n  if (actual instanceof Date && expected instanceof Date) {\n    return Object.is(actual.getTime(), expected.getTime());\n  }\n  if (typeof actual === \"string\" && expected instanceof RegExp) {\n    return testRegExp(expected, actual);\n  }\n  return Object.is(actual, expected);\n}\n\nfunction testRegExp(pattern: RegExp, text: string): boolean {\n  if (!pattern.global && !pattern.sticky) {\n    return pattern.test(text);\n  }\n  const clone = new RegExp(pattern.source, pattern.flags);\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(record: LogRecord): string {\n  return messageFormatter(record).slice(0, -1);\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}: ${formatPropertyValue(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}: ${formatMessage(record)}${\n    formatProperties(record.properties)\n  }`;\n}\n\nfunction formatMessage(record: LogRecord): string {\n  try {\n    return renderMessage(record);\n  } catch (error) {\n    return formatAccessError(error);\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>> | null | undefined,\n): string {\n  const props: Readonly<Record<string, unknown>> = properties ?? {};\n  const entries = Object.keys(props);\n  if (entries.length < 1) return \"\";\n  const summary = entries.slice(0, 3).map((key) =>\n    `${key}: ${formatPropertyValue(props, key)}`\n  );\n  if (entries.length > 3) summary.push(`... ${entries.length - 3} more`);\n  return ` {${summary.join(\", \")}}`;\n}\n\nfunction formatPropertyValue(\n  properties: Readonly<Record<string, unknown>>,\n  key: string,\n): string {\n  try {\n    return formatValue(properties[key]);\n  } catch (error) {\n    return formatAccessError(error);\n  }\n}\n\nfunction formatAccessError(error: unknown): string {\n  return `<error: ${\n    error instanceof Error ? error.message : safeString(error)\n  }>`;\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 === \"number\" && !Number.isFinite(value)) {\n    return String(value);\n  }\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  if (value instanceof Map) return formatMap(value);\n  if (value instanceof Set) return formatSet(value);\n  try {\n    return safeJsonStringify(value) ?? safeString(value);\n  } catch {\n    return safeString(value);\n  }\n}\n\nfunction formatMap(value: ReadonlyMap<unknown, unknown>): string {\n  const label = `Map(${value.size})`;\n  try {\n    const contents = formatMapContents(value);\n    return `${label} ${safeJsonStringify(contents) ?? safeString(contents)}`;\n  } catch {\n    return label;\n  }\n}\n\nfunction formatSet(value: ReadonlySet<unknown>): string {\n  const label = `Set(${value.size})`;\n  try {\n    const contents = Array.from(value);\n    return `${label} ${safeJsonStringify(contents) ?? safeString(contents)}`;\n  } catch {\n    return label;\n  }\n}\n\nfunction safeJsonStringify(value: unknown): string | undefined {\n  const ancestors: object[] = [];\n  return JSON.stringify(value, function (\n    this: unknown,\n    _key: string,\n    item: unknown,\n  ): unknown {\n    if (typeof item === \"bigint\") return `${item}n`;\n    if (item instanceof RegExp) return String(item);\n    if (item instanceof Error) return `${item.name}: ${item.message}`;\n    if (typeof item === \"object\" && item != null) {\n      while (\n        ancestors.length > 0 &&\n        ancestors[ancestors.length - 1] !== this\n      ) {\n        ancestors.pop();\n      }\n      if (ancestors.includes(item)) return \"[Circular]\";\n      ancestors.push(item);\n      if (item instanceof Map) return formatMapContents(item);\n      if (item instanceof Set) return Array.from(item);\n    }\n    return item;\n  });\n}\n\nfunction formatMapContents(\n  value: ReadonlyMap<unknown, unknown>,\n): Readonly<Record<string, unknown>> | readonly (readonly [string, unknown])[] {\n  const entries = Array.from(\n    value,\n    ([key, entryValue]) => [safeString(key), entryValue] as const,\n  );\n  const keys = entries.map(([key]) => key);\n  const uniqueKeys = new Set(keys);\n  return uniqueKeys.size === keys.length\n    ? Object.fromEntries(entries)\n    : entries;\n}\n\nfunction safeString(value: unknown): string {\n  try {\n    return String(value);\n  } catch {\n    return Object.prototype.toString.call(value);\n  }\n}\n"],"mappings":"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"}