@logtape/adaptor-bunyan 2.1.0-dev.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024–2025 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,163 @@
+<!-- deno-fmt-ignore-file -->
+
+@logtape/adaptor-bunyan
+=======================
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+*@logtape/adaptor-bunyan* is a [LogTape] adapter that forwards log records to
+[Bunyan] loggers, enabling seamless integration between LogTape-enabled
+libraries and applications using Bunyan for logging infrastructure.
+
+[JSR badge]: https://jsr.io/badges/@logtape/adaptor-bunyan
+[JSR]: https://jsr.io/@logtape/adaptor-bunyan
+[npm badge]: https://img.shields.io/npm/v/@logtape/adaptor-bunyan?logo=npm
+[npm]: https://www.npmjs.com/package/@logtape/adaptor-bunyan
+[LogTape]: https://logtape.org/
+[Bunyan]: https://github.com/trentm/node-bunyan
+
+
+Installation
+------------
+
+~~~~ sh
+deno add jsr:@logtape/adaptor-bunyan  # for Deno
+npm  add     @logtape/adaptor-bunyan  # for npm
+pnpm add     @logtape/adaptor-bunyan  # for pnpm
+yarn add     @logtape/adaptor-bunyan  # for Yarn
+bun  add     @logtape/adaptor-bunyan  # for Bun
+~~~~
+
+
+Usage
+-----
+
+Bunyan does not provide a global default logger; create one with
+`bunyan.createLogger()` and pass it to the adapter.
+
+### Using the install() function
+
+The simplest way to integrate LogTape with Bunyan is to use the `install()`
+function:
+
+~~~~ typescript
+import bunyan from "bunyan";
+import { install } from "@logtape/adaptor-bunyan";
+
+const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+
+install(bunyanLogger);
+
+// That's it! All LogTape logs will now be routed to your Bunyan logger
+import { getLogger } from "@logtape/logtape";
+const logger = getLogger("my-app");
+logger.info("This will be logged through Bunyan");
+~~~~
+
+You can also pass configuration options:
+
+~~~~ typescript
+import { install } from "@logtape/adaptor-bunyan";
+
+install(bunyanLogger, {
+  category: {
+    position: "start",
+    decorator: "[]",
+    separator: "."
+  }
+});
+~~~~
+
+### Manual configuration
+
+For full control over the Bunyan integration, configure LogTape manually:
+
+~~~~ typescript
+import { configure } from "@logtape/logtape";
+import { getBunyanSink } from "@logtape/adaptor-bunyan";
+import bunyan from "bunyan";
+
+const bunyanLogger = bunyan.createLogger({
+  name: "my-app",
+  level: "info"
+});
+
+await configure({
+  sinks: {
+    bunyan: getBunyanSink(bunyanLogger, {
+      category: {
+        position: "start",
+        decorator: "[]",
+        separator: "."
+      }
+    })
+  },
+  loggers: [
+    { category: "my-library", sinks: ["bunyan"] }
+  ]
+});
+~~~~
+
+
+Category formatting
+-------------------
+
+The adapter supports flexible category formatting options:
+
+~~~~ typescript
+import { getBunyanSink } from "@logtape/adaptor-bunyan";
+
+// Hide categories completely (default)
+const sink1 = getBunyanSink(logger, { category: false });
+
+// Use default formatting ("·" separator and ":" decorator)
+const sink2 = getBunyanSink(logger, { category: true });
+
+// Custom formatting
+const sink3 = getBunyanSink(logger, {
+  category: {
+    position: "end",      // "start" or "end"
+    decorator: "[]",      // "[]", "()", "<>", "{}", ":", "-", "|", "/", ""
+    separator: "::"       // custom separator for multi-part categories
+  }
+});
+~~~~
+
+
+Customizing interpolated value formatting
+-----------------------------------------
+
+By default the adapter renders interpolated values in the message template
+with `node:util.inspect()` (`breakLength: Infinity`).  Provide a
+`valueFormatter` to override that — for example, to use `JSON.stringify`
+or a redaction-aware serializer:
+
+~~~~ typescript
+import { getBunyanSink } from "@logtape/adaptor-bunyan";
+
+const sink = getBunyanSink(logger, {
+  valueFormatter: (value) => JSON.stringify(value),
+});
+~~~~
+
+
+Properties and Bunyan reserved fields
+-------------------------------------
+
+LogTape `record.properties` are passed verbatim to Bunyan as the merge-object
+of the call.  Bunyan automatically applies any `serializers` configured on
+the logger to matching top-level fields.
+
+Bunyan reserves a small set of field names (`name`, `hostname`, `pid`,
+`level`, `time`, `msg`, `src`, `v`).  If your LogTape properties happen to
+contain any of these names, Bunyan's normal collision behaviour applies —
+configure your structured property names to avoid conflicts.
+
+
+Docs
+----
+
+See the [API reference] on JSR for further details.
+
+[API reference]: https://jsr.io/@logtape/adaptor-bunyan/doc

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/mod.cjs

@@ -0,0 +1,181 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const node_util = require_rolldown_runtime.__toESM(require("node:util"));
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/mod.ts
+function defaultValueFormatter(value) {
+	return (0, node_util.inspect)(value, { breakLength: Infinity });
+}
+function renderMessage(parts, valueFormatter) {
+	let rendered = "";
+	for (let i = 0; i < parts.length; i++) if (i % 2 === 0) rendered += parts[i];
+	else rendered += valueFormatter(parts[i]);
+	return rendered;
+}
+function decorateCategoryStart(category, decorator) {
+	switch (decorator) {
+		case "[]": return `[${category}] `;
+		case "()": return `(${category}) `;
+		case "<>": return `<${category}> `;
+		case "{}": return `{${category}} `;
+		case ":": return `${category}: `;
+		case "-": return `${category} - `;
+		case "|": return `${category} | `;
+		case "/": return `${category} / `;
+		case "": return `${category} `;
+	}
+}
+function decorateCategoryEnd(category, decorator) {
+	switch (decorator) {
+		case "[]": return ` [${category}]`;
+		case "()": return ` (${category})`;
+		case "<>": return ` <${category}>`;
+		case "{}": return ` {${category}}`;
+		case ":": return `: ${category}`;
+		case "-": return ` - ${category}`;
+		case "|": return ` | ${category}`;
+		case "/": return ` / ${category}`;
+		case "": return ` ${category}`;
+	}
+}
+/**
+* Creates a LogTape sink that forwards log records to a Bunyan logger.
+*
+* Bunyan does not provide a global default logger; you must create one
+* with `bunyan.createLogger({ name: "..." })` and pass it in.
+*
+* LogTape's `record.properties` are passed verbatim to Bunyan as the
+* merge-object, so any `serializers` configured on the Bunyan logger
+* apply automatically.  Bunyan's reserved fields (`name`, `hostname`,
+* `pid`, `level`, `time`, `msg`, `src`, `v`) should not be used as
+* property keys.
+*
+* @example
+* ```typescript
+* import { configure } from "@logtape/logtape";
+* import { getBunyanSink } from "@logtape/adaptor-bunyan";
+* import bunyan from "bunyan";
+*
+* const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+*
+* await configure({
+*   sinks: {
+*     bunyan: getBunyanSink(bunyanLogger, {
+*       category: {
+*         position: "start",
+*         decorator: "[]",
+*         separator: "."
+*       }
+*     })
+*   },
+*   loggers: [
+*     { category: "my-library", sinks: ["bunyan"] }
+*   ]
+* });
+* ```
+*
+* @param logger The Bunyan logger instance to forward logs to.
+* @param options Configuration options for the sink adapter.
+* @returns A LogTape sink function that can be used in LogTape configuration.
+* @since 2.1.0
+*/
+function getBunyanSink(logger, options = {}) {
+	const categoryOptions = !options.category ? void 0 : typeof options.category === "object" ? options.category : {};
+	const category = categoryOptions == null ? void 0 : {
+		separator: categoryOptions.separator ?? "·",
+		position: categoryOptions.position ?? "start",
+		decorator: categoryOptions.decorator ?? ":"
+	};
+	const valueFormatter = options.valueFormatter ?? defaultValueFormatter;
+	return (record) => {
+		let message = "";
+		if (category != null && record.category.length > 0) {
+			const joined = record.category.join(category.separator);
+			if (category.position === "start") message += decorateCategoryStart(joined, category.decorator);
+			message += renderMessage(record.message, valueFormatter);
+			if (category.position === "end") message += decorateCategoryEnd(joined, category.decorator);
+		} else message = renderMessage(record.message, valueFormatter);
+		const properties = record.properties;
+		switch (record.level) {
+			case "trace":
+				logger.trace(properties, message);
+				return;
+			case "debug":
+				logger.debug(properties, message);
+				return;
+			case "info":
+				logger.info(properties, message);
+				return;
+			case "warning":
+				logger.warn(properties, message);
+				return;
+			case "error":
+				logger.error(properties, message);
+				return;
+			case "fatal":
+				logger.fatal(properties, message);
+				return;
+		}
+	};
+}
+/**
+* Automatically configures LogTape to route all logs to a Bunyan logger.
+*
+* This is a convenience function that wires up `getBunyanSink()` as
+* LogTape's catch-all sink and routes the meta logger
+* (`["logtape", "meta"]`) to the same sink with `lowestLevel: "warning"`,
+* matching the conventions of the other adapter packages.
+*
+* Bunyan does not provide a global default logger, so the logger argument
+* is required.  Create one with `bunyan.createLogger({ name: "..." })`
+* and pass it in.
+*
+* @example Basic auto-configuration
+* ```typescript
+* import bunyan from "bunyan";
+* import { install } from "@logtape/adaptor-bunyan";
+*
+* const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+* install(bunyanLogger);
+*
+* import { getLogger } from "@logtape/logtape";
+* const logger = getLogger("my-app");
+* logger.info("This will be logged through Bunyan");
+* ```
+*
+* @example Auto-configuration with custom options
+* ```typescript
+* import bunyan from "bunyan";
+* import { install } from "@logtape/adaptor-bunyan";
+*
+* const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+* install(bunyanLogger, {
+*   category: {
+*     position: "start",
+*     decorator: "[]",
+*     separator: "."
+*   }
+* });
+* ```
+*
+* @param logger The Bunyan logger instance to forward logs to.
+* @param options Configuration options for the sink adapter.
+* @since 2.1.0
+*/
+function install(logger, options = {}) {
+	(0, __logtape_logtape.configureSync)({
+		sinks: { bunyan: getBunyanSink(logger, options) },
+		loggers: [{
+			category: ["logtape", "meta"],
+			sinks: ["bunyan"],
+			lowestLevel: "warning"
+		}, {
+			category: [],
+			sinks: ["bunyan"]
+		}]
+	});
+}
+
+//#endregion
+exports.getBunyanSink = getBunyanSink;
+exports.install = install;

package/dist/mod.d.cts

@@ -0,0 +1,169 @@
+import { Sink } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * A structural representation of a [Bunyan] logger sufficient for the
+ * adapter's needs.  Avoids importing Bunyan's own type definitions so the
+ * package builds cleanly under both Deno and Node.js.
+ *
+ * [Bunyan]: https://github.com/trentm/node-bunyan
+ *
+ * @since 2.1.0
+ */
+interface BunyanLogger {
+  trace(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+  debug(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+  info(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+  warn(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+  error(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+  fatal(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+}
+/**
+ * Options for configuring the Bunyan sink adapter.
+ * @since 2.1.0
+ */
+interface BunyanSinkOptions {
+  /**
+   * Configuration for how LogTape categories are handled in Bunyan logs.
+   * - `false` or `undefined`: Categories are not included in the log message
+   * - `true`: Categories are included with default formatting
+   * - `CategoryOptions`: Custom category formatting configuration
+   */
+  readonly category?: boolean | CategoryOptions;
+  /**
+   * A function that converts an interpolated value in the message template
+   * to a string.  By default, values are formatted with
+   * `node:util#inspect()` using `breakLength: Infinity` so each value
+   * appears on a single line in the rendered `msg` field.
+   *
+   * Supply a custom formatter to use, for example, `JSON.stringify`,
+   * a redaction-aware serializer, or any other strategy.
+   * @default `(value) => inspect(value, { breakLength: Infinity })`
+   */
+  readonly valueFormatter?: (value: unknown) => string;
+}
+/**
+ * Configuration options for formatting LogTape categories in Bunyan log
+ * messages.
+ * @since 2.1.0
+ */
+interface CategoryOptions {
+  /**
+   * The separator used to join category parts when multiple categories exist.
+   * @default "·"
+   */
+  readonly separator?: string;
+  /**
+   * Where to position the category in the log message.
+   * - `"start"`: Category appears at the beginning of the message
+   * - `"end"`: Category appears at the end of the message
+   * @default "start"
+   */
+  readonly position?: "start" | "end";
+  /**
+   * The decorator used to format the category in the log message.
+   * - `"[]"`: [category] format
+   * - `"()"`: (category) format
+   * - `"<>"`: <category> format
+   * - `"{}"`: {category} format
+   * - `":"`: category: format
+   * - `"-"`: category - format
+   * - `"|"`: category | format
+   * - `"/"`: category / format
+   * - `""`: category format (no decoration)
+   * @default ":"
+   */
+  readonly decorator?: "[]" | "()" | "<>" | "{}" | ":" | "-" | "|" | "/" | "";
+}
+/**
+ * Creates a LogTape sink that forwards log records to a Bunyan logger.
+ *
+ * Bunyan does not provide a global default logger; you must create one
+ * with `bunyan.createLogger({ name: "..." })` and pass it in.
+ *
+ * LogTape's `record.properties` are passed verbatim to Bunyan as the
+ * merge-object, so any `serializers` configured on the Bunyan logger
+ * apply automatically.  Bunyan's reserved fields (`name`, `hostname`,
+ * `pid`, `level`, `time`, `msg`, `src`, `v`) should not be used as
+ * property keys.
+ *
+ * @example
+ * ```typescript
+ * import { configure } from "@logtape/logtape";
+ * import { getBunyanSink } from "@logtape/adaptor-bunyan";
+ * import bunyan from "bunyan";
+ *
+ * const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+ *
+ * await configure({
+ *   sinks: {
+ *     bunyan: getBunyanSink(bunyanLogger, {
+ *       category: {
+ *         position: "start",
+ *         decorator: "[]",
+ *         separator: "."
+ *       }
+ *     })
+ *   },
+ *   loggers: [
+ *     { category: "my-library", sinks: ["bunyan"] }
+ *   ]
+ * });
+ * ```
+ *
+ * @param logger The Bunyan logger instance to forward logs to.
+ * @param options Configuration options for the sink adapter.
+ * @returns A LogTape sink function that can be used in LogTape configuration.
+ * @since 2.1.0
+ */
+declare function getBunyanSink(logger: BunyanLogger, options?: BunyanSinkOptions): Sink;
+/**
+ * Automatically configures LogTape to route all logs to a Bunyan logger.
+ *
+ * This is a convenience function that wires up `getBunyanSink()` as
+ * LogTape's catch-all sink and routes the meta logger
+ * (`["logtape", "meta"]`) to the same sink with `lowestLevel: "warning"`,
+ * matching the conventions of the other adapter packages.
+ *
+ * Bunyan does not provide a global default logger, so the logger argument
+ * is required.  Create one with `bunyan.createLogger({ name: "..." })`
+ * and pass it in.
+ *
+ * @example Basic auto-configuration
+ * ```typescript
+ * import bunyan from "bunyan";
+ * import { install } from "@logtape/adaptor-bunyan";
+ *
+ * const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+ * install(bunyanLogger);
+ *
+ * import { getLogger } from "@logtape/logtape";
+ * const logger = getLogger("my-app");
+ * logger.info("This will be logged through Bunyan");
+ * ```
+ *
+ * @example Auto-configuration with custom options
+ * ```typescript
+ * import bunyan from "bunyan";
+ * import { install } from "@logtape/adaptor-bunyan";
+ *
+ * const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+ * install(bunyanLogger, {
+ *   category: {
+ *     position: "start",
+ *     decorator: "[]",
+ *     separator: "."
+ *   }
+ * });
+ * ```
+ *
+ * @param logger The Bunyan logger instance to forward logs to.
+ * @param options Configuration options for the sink adapter.
+ * @since 2.1.0
+ */
+declare function install(logger: BunyanLogger, options?: BunyanSinkOptions): void;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { BunyanLogger, BunyanSinkOptions, CategoryOptions, getBunyanSink, install };
+//# 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":";;;;;;AAYA;;;;;;;AA2BiB,UA3BA,YAAA,CA2BA;EAAM,KAAA,CAAA,WAAA,EAzBN,MAyBM,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAUN,KAAA,CAAA,WAAA,EA9BA,MA8BiB,CAAA,MAOF,EAAA,OAAA,CAAA,EAAA,MAAe,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAoB9B,IAAA,CAAA,WAAA,EApDA,MAoDe,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EA+IhB,IAAA,CAAA,WAAa,EA9LZ,MA8LY,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAAA,KAAA,CAAA,WAAA,EAzLZ,MAyLY,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAAA,KACnB,CAAA,WAAA,EArLO,MAqLP,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;;;AAEH;AA+FP;;AACU,UA7QO,iBAAA,CA6QP;EAAY;AACW;;;;;gCAvQD;;;;;;;;;;;;;;;;;;UAoBf,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+ID,aAAA,SACN,wBACC,oBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+Fa,OAAA,SACN,wBACC"}

package/dist/mod.d.ts

@@ -0,0 +1,169 @@
+import { Sink } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * A structural representation of a [Bunyan] logger sufficient for the
+ * adapter's needs.  Avoids importing Bunyan's own type definitions so the
+ * package builds cleanly under both Deno and Node.js.
+ *
+ * [Bunyan]: https://github.com/trentm/node-bunyan
+ *
+ * @since 2.1.0
+ */
+interface BunyanLogger {
+  trace(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+  debug(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+  info(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+  warn(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+  error(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+  fatal(mergeObject: Record<string, unknown>, format: string, ...args: unknown[]): void;
+}
+/**
+ * Options for configuring the Bunyan sink adapter.
+ * @since 2.1.0
+ */
+interface BunyanSinkOptions {
+  /**
+   * Configuration for how LogTape categories are handled in Bunyan logs.
+   * - `false` or `undefined`: Categories are not included in the log message
+   * - `true`: Categories are included with default formatting
+   * - `CategoryOptions`: Custom category formatting configuration
+   */
+  readonly category?: boolean | CategoryOptions;
+  /**
+   * A function that converts an interpolated value in the message template
+   * to a string.  By default, values are formatted with
+   * `node:util#inspect()` using `breakLength: Infinity` so each value
+   * appears on a single line in the rendered `msg` field.
+   *
+   * Supply a custom formatter to use, for example, `JSON.stringify`,
+   * a redaction-aware serializer, or any other strategy.
+   * @default `(value) => inspect(value, { breakLength: Infinity })`
+   */
+  readonly valueFormatter?: (value: unknown) => string;
+}
+/**
+ * Configuration options for formatting LogTape categories in Bunyan log
+ * messages.
+ * @since 2.1.0
+ */
+interface CategoryOptions {
+  /**
+   * The separator used to join category parts when multiple categories exist.
+   * @default "·"
+   */
+  readonly separator?: string;
+  /**
+   * Where to position the category in the log message.
+   * - `"start"`: Category appears at the beginning of the message
+   * - `"end"`: Category appears at the end of the message
+   * @default "start"
+   */
+  readonly position?: "start" | "end";
+  /**
+   * The decorator used to format the category in the log message.
+   * - `"[]"`: [category] format
+   * - `"()"`: (category) format
+   * - `"<>"`: <category> format
+   * - `"{}"`: {category} format
+   * - `":"`: category: format
+   * - `"-"`: category - format
+   * - `"|"`: category | format
+   * - `"/"`: category / format
+   * - `""`: category format (no decoration)
+   * @default ":"
+   */
+  readonly decorator?: "[]" | "()" | "<>" | "{}" | ":" | "-" | "|" | "/" | "";
+}
+/**
+ * Creates a LogTape sink that forwards log records to a Bunyan logger.
+ *
+ * Bunyan does not provide a global default logger; you must create one
+ * with `bunyan.createLogger({ name: "..." })` and pass it in.
+ *
+ * LogTape's `record.properties` are passed verbatim to Bunyan as the
+ * merge-object, so any `serializers` configured on the Bunyan logger
+ * apply automatically.  Bunyan's reserved fields (`name`, `hostname`,
+ * `pid`, `level`, `time`, `msg`, `src`, `v`) should not be used as
+ * property keys.
+ *
+ * @example
+ * ```typescript
+ * import { configure } from "@logtape/logtape";
+ * import { getBunyanSink } from "@logtape/adaptor-bunyan";
+ * import bunyan from "bunyan";
+ *
+ * const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+ *
+ * await configure({
+ *   sinks: {
+ *     bunyan: getBunyanSink(bunyanLogger, {
+ *       category: {
+ *         position: "start",
+ *         decorator: "[]",
+ *         separator: "."
+ *       }
+ *     })
+ *   },
+ *   loggers: [
+ *     { category: "my-library", sinks: ["bunyan"] }
+ *   ]
+ * });
+ * ```
+ *
+ * @param logger The Bunyan logger instance to forward logs to.
+ * @param options Configuration options for the sink adapter.
+ * @returns A LogTape sink function that can be used in LogTape configuration.
+ * @since 2.1.0
+ */
+declare function getBunyanSink(logger: BunyanLogger, options?: BunyanSinkOptions): Sink;
+/**
+ * Automatically configures LogTape to route all logs to a Bunyan logger.
+ *
+ * This is a convenience function that wires up `getBunyanSink()` as
+ * LogTape's catch-all sink and routes the meta logger
+ * (`["logtape", "meta"]`) to the same sink with `lowestLevel: "warning"`,
+ * matching the conventions of the other adapter packages.
+ *
+ * Bunyan does not provide a global default logger, so the logger argument
+ * is required.  Create one with `bunyan.createLogger({ name: "..." })`
+ * and pass it in.
+ *
+ * @example Basic auto-configuration
+ * ```typescript
+ * import bunyan from "bunyan";
+ * import { install } from "@logtape/adaptor-bunyan";
+ *
+ * const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+ * install(bunyanLogger);
+ *
+ * import { getLogger } from "@logtape/logtape";
+ * const logger = getLogger("my-app");
+ * logger.info("This will be logged through Bunyan");
+ * ```
+ *
+ * @example Auto-configuration with custom options
+ * ```typescript
+ * import bunyan from "bunyan";
+ * import { install } from "@logtape/adaptor-bunyan";
+ *
+ * const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+ * install(bunyanLogger, {
+ *   category: {
+ *     position: "start",
+ *     decorator: "[]",
+ *     separator: "."
+ *   }
+ * });
+ * ```
+ *
+ * @param logger The Bunyan logger instance to forward logs to.
+ * @param options Configuration options for the sink adapter.
+ * @since 2.1.0
+ */
+declare function install(logger: BunyanLogger, options?: BunyanSinkOptions): void;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { BunyanLogger, BunyanSinkOptions, CategoryOptions, getBunyanSink, install };
+//# 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":";;;;;;AAYA;;;;;;;AA2BiB,UA3BA,YAAA,CA2BA;EAAM,KAAA,CAAA,WAAA,EAzBN,MAyBM,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAUN,KAAA,CAAA,WAAA,EA9BA,MA8BiB,CAAA,MAOF,EAAA,OAAA,CAAA,EAAA,MAAe,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAoB9B,IAAA,CAAA,WAAA,EApDA,MAoDe,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EA+IhB,IAAA,CAAA,WAAa,EA9LZ,MA8LY,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAAA,KAAA,CAAA,WAAA,EAzLZ,MAyLY,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAAA,KACnB,CAAA,WAAA,EArLO,MAqLP,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;;;AAEH;AA+FP;;AACU,UA7QO,iBAAA,CA6QP;EAAY;AACW;;;;;gCAvQD;;;;;;;;;;;;;;;;;;UAoBf,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+ID,aAAA,SACN,wBACC,oBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+Fa,OAAA,SACN,wBACC"}

package/dist/mod.js

@@ -0,0 +1,180 @@
+import { inspect } from "node:util";
+import { configureSync } from "@logtape/logtape";
+
+//#region src/mod.ts
+function defaultValueFormatter(value) {
+	return inspect(value, { breakLength: Infinity });
+}
+function renderMessage(parts, valueFormatter) {
+	let rendered = "";
+	for (let i = 0; i < parts.length; i++) if (i % 2 === 0) rendered += parts[i];
+	else rendered += valueFormatter(parts[i]);
+	return rendered;
+}
+function decorateCategoryStart(category, decorator) {
+	switch (decorator) {
+		case "[]": return `[${category}] `;
+		case "()": return `(${category}) `;
+		case "<>": return `<${category}> `;
+		case "{}": return `{${category}} `;
+		case ":": return `${category}: `;
+		case "-": return `${category} - `;
+		case "|": return `${category} | `;
+		case "/": return `${category} / `;
+		case "": return `${category} `;
+	}
+}
+function decorateCategoryEnd(category, decorator) {
+	switch (decorator) {
+		case "[]": return ` [${category}]`;
+		case "()": return ` (${category})`;
+		case "<>": return ` <${category}>`;
+		case "{}": return ` {${category}}`;
+		case ":": return `: ${category}`;
+		case "-": return ` - ${category}`;
+		case "|": return ` | ${category}`;
+		case "/": return ` / ${category}`;
+		case "": return ` ${category}`;
+	}
+}
+/**
+* Creates a LogTape sink that forwards log records to a Bunyan logger.
+*
+* Bunyan does not provide a global default logger; you must create one
+* with `bunyan.createLogger({ name: "..." })` and pass it in.
+*
+* LogTape's `record.properties` are passed verbatim to Bunyan as the
+* merge-object, so any `serializers` configured on the Bunyan logger
+* apply automatically.  Bunyan's reserved fields (`name`, `hostname`,
+* `pid`, `level`, `time`, `msg`, `src`, `v`) should not be used as
+* property keys.
+*
+* @example
+* ```typescript
+* import { configure } from "@logtape/logtape";
+* import { getBunyanSink } from "@logtape/adaptor-bunyan";
+* import bunyan from "bunyan";
+*
+* const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+*
+* await configure({
+*   sinks: {
+*     bunyan: getBunyanSink(bunyanLogger, {
+*       category: {
+*         position: "start",
+*         decorator: "[]",
+*         separator: "."
+*       }
+*     })
+*   },
+*   loggers: [
+*     { category: "my-library", sinks: ["bunyan"] }
+*   ]
+* });
+* ```
+*
+* @param logger The Bunyan logger instance to forward logs to.
+* @param options Configuration options for the sink adapter.
+* @returns A LogTape sink function that can be used in LogTape configuration.
+* @since 2.1.0
+*/
+function getBunyanSink(logger, options = {}) {
+	const categoryOptions = !options.category ? void 0 : typeof options.category === "object" ? options.category : {};
+	const category = categoryOptions == null ? void 0 : {
+		separator: categoryOptions.separator ?? "·",
+		position: categoryOptions.position ?? "start",
+		decorator: categoryOptions.decorator ?? ":"
+	};
+	const valueFormatter = options.valueFormatter ?? defaultValueFormatter;
+	return (record) => {
+		let message = "";
+		if (category != null && record.category.length > 0) {
+			const joined = record.category.join(category.separator);
+			if (category.position === "start") message += decorateCategoryStart(joined, category.decorator);
+			message += renderMessage(record.message, valueFormatter);
+			if (category.position === "end") message += decorateCategoryEnd(joined, category.decorator);
+		} else message = renderMessage(record.message, valueFormatter);
+		const properties = record.properties;
+		switch (record.level) {
+			case "trace":
+				logger.trace(properties, message);
+				return;
+			case "debug":
+				logger.debug(properties, message);
+				return;
+			case "info":
+				logger.info(properties, message);
+				return;
+			case "warning":
+				logger.warn(properties, message);
+				return;
+			case "error":
+				logger.error(properties, message);
+				return;
+			case "fatal":
+				logger.fatal(properties, message);
+				return;
+		}
+	};
+}
+/**
+* Automatically configures LogTape to route all logs to a Bunyan logger.
+*
+* This is a convenience function that wires up `getBunyanSink()` as
+* LogTape's catch-all sink and routes the meta logger
+* (`["logtape", "meta"]`) to the same sink with `lowestLevel: "warning"`,
+* matching the conventions of the other adapter packages.
+*
+* Bunyan does not provide a global default logger, so the logger argument
+* is required.  Create one with `bunyan.createLogger({ name: "..." })`
+* and pass it in.
+*
+* @example Basic auto-configuration
+* ```typescript
+* import bunyan from "bunyan";
+* import { install } from "@logtape/adaptor-bunyan";
+*
+* const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+* install(bunyanLogger);
+*
+* import { getLogger } from "@logtape/logtape";
+* const logger = getLogger("my-app");
+* logger.info("This will be logged through Bunyan");
+* ```
+*
+* @example Auto-configuration with custom options
+* ```typescript
+* import bunyan from "bunyan";
+* import { install } from "@logtape/adaptor-bunyan";
+*
+* const bunyanLogger = bunyan.createLogger({ name: "my-app" });
+* install(bunyanLogger, {
+*   category: {
+*     position: "start",
+*     decorator: "[]",
+*     separator: "."
+*   }
+* });
+* ```
+*
+* @param logger The Bunyan logger instance to forward logs to.
+* @param options Configuration options for the sink adapter.
+* @since 2.1.0
+*/
+function install(logger, options = {}) {
+	configureSync({
+		sinks: { bunyan: getBunyanSink(logger, options) },
+		loggers: [{
+			category: ["logtape", "meta"],
+			sinks: ["bunyan"],
+			lowestLevel: "warning"
+		}, {
+			category: [],
+			sinks: ["bunyan"]
+		}]
+	});
+}
+
+//#endregion
+export { getBunyanSink, install };
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","names":["value: unknown","parts: readonly (string | unknown)[]","valueFormatter: (value: unknown) => string","category: string","decorator: Required<CategoryOptions>[\"decorator\"]","logger: BunyanLogger","options: BunyanSinkOptions","category: Required<CategoryOptions> | undefined","record: LogRecord"],"sources":["../src/mod.ts"],"sourcesContent":["import { inspect } from \"node:util\";\nimport { configureSync, type LogRecord, type Sink } from \"@logtape/logtape\";\n\n/**\n * A structural representation of a [Bunyan] logger sufficient for the\n * adapter's needs.  Avoids importing Bunyan's own type definitions so the\n * package builds cleanly under both Deno and Node.js.\n *\n * [Bunyan]: https://github.com/trentm/node-bunyan\n *\n * @since 2.1.0\n */\nexport interface BunyanLogger {\n  trace(\n    mergeObject: Record<string, unknown>,\n    format: string,\n    ...args: unknown[]\n  ): void;\n  debug(\n    mergeObject: Record<string, unknown>,\n    format: string,\n    ...args: unknown[]\n  ): void;\n  info(\n    mergeObject: Record<string, unknown>,\n    format: string,\n    ...args: unknown[]\n  ): void;\n  warn(\n    mergeObject: Record<string, unknown>,\n    format: string,\n    ...args: unknown[]\n  ): void;\n  error(\n    mergeObject: Record<string, unknown>,\n    format: string,\n    ...args: unknown[]\n  ): void;\n  fatal(\n    mergeObject: Record<string, unknown>,\n    format: string,\n    ...args: unknown[]\n  ): void;\n}\n\n/**\n * Options for configuring the Bunyan sink adapter.\n * @since 2.1.0\n */\nexport interface BunyanSinkOptions {\n  /**\n   * Configuration for how LogTape categories are handled in Bunyan logs.\n   * - `false` or `undefined`: Categories are not included in the log message\n   * - `true`: Categories are included with default formatting\n   * - `CategoryOptions`: Custom category formatting configuration\n   */\n  readonly category?: boolean | CategoryOptions;\n\n  /**\n   * A function that converts an interpolated value in the message template\n   * to a string.  By default, values are formatted with\n   * `node:util#inspect()` using `breakLength: Infinity` so each value\n   * appears on a single line in the rendered `msg` field.\n   *\n   * Supply a custom formatter to use, for example, `JSON.stringify`,\n   * a redaction-aware serializer, or any other strategy.\n   * @default `(value) => inspect(value, { breakLength: Infinity })`\n   */\n  readonly valueFormatter?: (value: unknown) => string;\n}\n\n/**\n * Configuration options for formatting LogTape categories in Bunyan log\n * messages.\n * @since 2.1.0\n */\nexport interface CategoryOptions {\n  /**\n   * The separator used to join category parts when multiple categories exist.\n   * @default \"·\"\n   */\n  readonly separator?: string;\n\n  /**\n   * Where to position the category in the log message.\n   * - `\"start\"`: Category appears at the beginning of the message\n   * - `\"end\"`: Category appears at the end of the message\n   * @default \"start\"\n   */\n  readonly position?: \"start\" | \"end\";\n\n  /**\n   * The decorator used to format the category in the log message.\n   * - `\"[]\"`: [category] format\n   * - `\"()\"`: (category) format\n   * - `\"<>\"`: <category> format\n   * - `\"{}\"`: {category} format\n   * - `\":\"`: category: format\n   * - `\"-\"`: category - format\n   * - `\"|\"`: category | format\n   * - `\"/\"`: category / format\n   * - `\"\"`: category format (no decoration)\n   * @default \":\"\n   */\n  readonly decorator?: \"[]\" | \"()\" | \"<>\" | \"{}\" | \":\" | \"-\" | \"|\" | \"/\" | \"\";\n}\n\nfunction defaultValueFormatter(value: unknown): string {\n  return inspect(value, { breakLength: Infinity });\n}\n\nfunction renderMessage(\n  parts: readonly (string | unknown)[],\n  valueFormatter: (value: unknown) => string,\n): string {\n  let rendered = \"\";\n  for (let i = 0; i < parts.length; i++) {\n    if (i % 2 === 0) {\n      rendered += parts[i] as string;\n    } else {\n      rendered += valueFormatter(parts[i]);\n    }\n  }\n  return rendered;\n}\n\nfunction decorateCategoryStart(\n  category: string,\n  decorator: Required<CategoryOptions>[\"decorator\"],\n): string {\n  switch (decorator) {\n    case \"[]\":\n      return `[${category}] `;\n    case \"()\":\n      return `(${category}) `;\n    case \"<>\":\n      return `<${category}> `;\n    case \"{}\":\n      return `{${category}} `;\n    case \":\":\n      return `${category}: `;\n    case \"-\":\n      return `${category} - `;\n    case \"|\":\n      return `${category} | `;\n    case \"/\":\n      return `${category} / `;\n    case \"\":\n      return `${category} `;\n  }\n}\n\nfunction decorateCategoryEnd(\n  category: string,\n  decorator: Required<CategoryOptions>[\"decorator\"],\n): string {\n  switch (decorator) {\n    case \"[]\":\n      return ` [${category}]`;\n    case \"()\":\n      return ` (${category})`;\n    case \"<>\":\n      return ` <${category}>`;\n    case \"{}\":\n      return ` {${category}}`;\n    case \":\":\n      return `: ${category}`;\n    case \"-\":\n      return ` - ${category}`;\n    case \"|\":\n      return ` | ${category}`;\n    case \"/\":\n      return ` / ${category}`;\n    case \"\":\n      return ` ${category}`;\n  }\n}\n\n/**\n * Creates a LogTape sink that forwards log records to a Bunyan logger.\n *\n * Bunyan does not provide a global default logger; you must create one\n * with `bunyan.createLogger({ name: \"...\" })` and pass it in.\n *\n * LogTape's `record.properties` are passed verbatim to Bunyan as the\n * merge-object, so any `serializers` configured on the Bunyan logger\n * apply automatically.  Bunyan's reserved fields (`name`, `hostname`,\n * `pid`, `level`, `time`, `msg`, `src`, `v`) should not be used as\n * property keys.\n *\n * @example\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getBunyanSink } from \"@logtape/adaptor-bunyan\";\n * import bunyan from \"bunyan\";\n *\n * const bunyanLogger = bunyan.createLogger({ name: \"my-app\" });\n *\n * await configure({\n *   sinks: {\n *     bunyan: getBunyanSink(bunyanLogger, {\n *       category: {\n *         position: \"start\",\n *         decorator: \"[]\",\n *         separator: \".\"\n *       }\n *     })\n *   },\n *   loggers: [\n *     { category: \"my-library\", sinks: [\"bunyan\"] }\n *   ]\n * });\n * ```\n *\n * @param logger The Bunyan logger instance to forward logs to.\n * @param options Configuration options for the sink adapter.\n * @returns A LogTape sink function that can be used in LogTape configuration.\n * @since 2.1.0\n */\nexport function getBunyanSink(\n  logger: BunyanLogger,\n  options: BunyanSinkOptions = {},\n): Sink {\n  const categoryOptions = !options.category\n    ? undefined\n    : typeof options.category === \"object\"\n    ? options.category\n    : {};\n  const category: Required<CategoryOptions> | undefined =\n    categoryOptions == null ? undefined : {\n      separator: categoryOptions.separator ?? \"·\",\n      position: categoryOptions.position ?? \"start\",\n      decorator: categoryOptions.decorator ?? \":\",\n    };\n  const valueFormatter = options.valueFormatter ?? defaultValueFormatter;\n  return (record: LogRecord) => {\n    let message = \"\";\n    if (category != null && record.category.length > 0) {\n      const joined = record.category.join(category.separator);\n      if (category.position === \"start\") {\n        message += decorateCategoryStart(joined, category.decorator);\n      }\n      message += renderMessage(record.message, valueFormatter);\n      if (category.position === \"end\") {\n        message += decorateCategoryEnd(joined, category.decorator);\n      }\n    } else {\n      message = renderMessage(record.message, valueFormatter);\n    }\n    const properties = record.properties as Record<string, unknown>;\n    switch (record.level) {\n      case \"trace\":\n        logger.trace(properties, message);\n        return;\n      case \"debug\":\n        logger.debug(properties, message);\n        return;\n      case \"info\":\n        logger.info(properties, message);\n        return;\n      case \"warning\":\n        logger.warn(properties, message);\n        return;\n      case \"error\":\n        logger.error(properties, message);\n        return;\n      case \"fatal\":\n        logger.fatal(properties, message);\n        return;\n    }\n  };\n}\n\n/**\n * Automatically configures LogTape to route all logs to a Bunyan logger.\n *\n * This is a convenience function that wires up `getBunyanSink()` as\n * LogTape's catch-all sink and routes the meta logger\n * (`[\"logtape\", \"meta\"]`) to the same sink with `lowestLevel: \"warning\"`,\n * matching the conventions of the other adapter packages.\n *\n * Bunyan does not provide a global default logger, so the logger argument\n * is required.  Create one with `bunyan.createLogger({ name: \"...\" })`\n * and pass it in.\n *\n * @example Basic auto-configuration\n * ```typescript\n * import bunyan from \"bunyan\";\n * import { install } from \"@logtape/adaptor-bunyan\";\n *\n * const bunyanLogger = bunyan.createLogger({ name: \"my-app\" });\n * install(bunyanLogger);\n *\n * import { getLogger } from \"@logtape/logtape\";\n * const logger = getLogger(\"my-app\");\n * logger.info(\"This will be logged through Bunyan\");\n * ```\n *\n * @example Auto-configuration with custom options\n * ```typescript\n * import bunyan from \"bunyan\";\n * import { install } from \"@logtape/adaptor-bunyan\";\n *\n * const bunyanLogger = bunyan.createLogger({ name: \"my-app\" });\n * install(bunyanLogger, {\n *   category: {\n *     position: \"start\",\n *     decorator: \"[]\",\n *     separator: \".\"\n *   }\n * });\n * ```\n *\n * @param logger The Bunyan logger instance to forward logs to.\n * @param options Configuration options for the sink adapter.\n * @since 2.1.0\n */\nexport function install(\n  logger: BunyanLogger,\n  options: BunyanSinkOptions = {},\n): void {\n  configureSync({\n    sinks: {\n      bunyan: getBunyanSink(logger, options),\n    },\n    loggers: [\n      {\n        category: [\"logtape\", \"meta\"],\n        sinks: [\"bunyan\"],\n        lowestLevel: \"warning\",\n      },\n      { category: [], sinks: [\"bunyan\"] },\n    ],\n  });\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@logtape/adaptor-bunyan",
+  "version": "2.1.0-dev.0",
+  "description": "Bunyan adapter for LogTape logging library",
+  "keywords": [
+    "logging",
+    "log",
+    "logger",
+    "bunyan",
+    "adapter",
+    "logtape",
+    "sink"
+  ],
+  "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/adaptor-bunyan/"
+  },
+  "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": {
+    "bunyan": "^1.8.0",
+    "@logtape/logtape": "^2.1.0"
+  },
+  "devDependencies": {
+    "@alinea/suite": "^0.6.3",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.13",
+    "@std/async": "npm:@jsr/std__async@^1.0.13",
+    "@types/bunyan": "^1.8.11",
+    "bunyan": "^1.8.15",
+    "tsdown": "^0.12.7",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test",
+    "test:deno": "deno test --allow-env --allow-sys",
+    "test-all": "tsdown && node --experimental-transform-types --test && bun test && deno test --allow-env --allow-sys"
+  }
+}