@vsfedorenko/next-logger 0.1.0 → 0.2.1

package/dist/index.js

@@ -2,98 +2,83 @@
 /**
  * # @vsfedorenko/next-logger
  *
- * A universal logging kit for Next.js. Monkeypatches Next.js' internal
- * logger (`next/dist/build/output/log`) and the global `console.*` so all
- * diagnostic output flows through a single level-controllable sink —
- * consola by default, with reporters for Sentry, JSON, and more — without a
- * custom Next.js server.
+ * A universal logging kit for Next.js. Wraps the global `console.*` (which
+ * Next.js' own internal logger also funnels through) so all diagnostic output
+ * flows through a single level-controllable consola sink — without monkey
+ * patching Next's module (which is unreachable under Turbopack).
  *
  * ## Usage
  *
- * ### Instrumentation hook (Next.js ≥ 9.3 / instrumentationHook)
+ * Wrap your Next config and call `init()` from instrumentation:
+ *
+ * ```ts
+ * // next.config.ts
+ * import { withLogger } from "@vsfedorenko/next-logger";
+ *
+ * export default withLogger({ consola: { level: 4 } })({
+ *   // ...your next config
+ * });
+ * ```
  *
  * ```ts
  * // instrumentation.ts (project root)
  * export async function register() {
  *   if (process.env.NEXT_RUNTIME === "nodejs") {
- *     await import("@vsfedorenko/next-logger");
+ *     const { init } = await import("@vsfedorenko/next-logger");
+ *     init();
  *   }
  * }
  * ```
  *
- * The default import applies both patches (Next logger + console). To patch
- * only Next's logger:
- *
- * ```ts
- * await import("@vsfedorenko/next-logger/presets/next-only");
- * ```
- *
- * ### `-r` preload
- *
- * ```sh
- * node -r @vsfedorenko/next-logger server.js
- * ```
+ * `init()` patches `console.*`. To skip patching console, pass
+ * `{ console: false }`.
  *
  * ## Configuration
  *
- * Optional `next-logger.config.ts` (discovered from cwd upward):
- *
- * ```ts
- * import { createConsola } from "consola";
- *
- * export default {
- *   consola: createConsola({ level: 4 }), // full custom instance
- * };
- * ```
- *
- * Or partial options (merged with defaults):
+ * `withLogger(options)` serialises `options` into the `NEXT_LOGGER_CONFIG` env
+ * var via Next.js' validated `env` config key (no "Unrecognized key" warning),
+ * inlined at build time and read back at runtime. Only serialisable consola
+ * options are supported (level, formatOptions, …):
  *
  * ```ts
- * export default {
- *   consola: { level: 4, formatOptions: { date: false } },
- * };
- * ```
- *
- * Or a factory (receives the library's default options):
- *
- * ```ts
- * import type { ConsolaOptions } from "consola";
- *
- * export default {
- *   consola: (defaults: Partial<ConsolaOptions>) =>
- *     createConsola({ ...defaults, level: 5 }),
- * };
+ * withLogger({ consola: { level: 4, formatOptions: { date: false } } })
  * ```
  *
  * ## Log level
  *
- * Without a config file, the level resolves from (in order) `LOG_LEVEL` or
+ * Without `withLogger`, the level resolves from (in order) `LOG_LEVEL` or
  * `NEXT_PUBLIC_LOG_LEVEL` (numeric or named: silent/fatal/error/warn/info/log/
  * debug/trace/verbose), falling back to `3` (info).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.skipEmpty = exports.isEmptyMessage = exports.CONSOLE_METHODS = exports.routeConsoleMethod = exports.patchConsole = exports.NEXT_PREFIXES = exports.routeNextMethod = exports.patchNext = exports.createJsonReporter = exports.resolveFormat = exports.defaultConsolaOptions = exports.loadConfig = exports.logger = void 0;
-require("./presets/all");
-// Core instance + config.
+exports.skipEmpty = exports.isEmptyMessage = exports.isNextLog = exports.CONSOLE_METHODS = exports.routeConsoleMethod = exports.patchConsole = exports.createJsonReporter = exports.resolveFormat = exports.defaultConsolaOptions = exports.CONFIG_ENV_VAR = exports.resolveLoggerConfig = exports.loadConfig = exports.buildLogger = exports.getLogger = exports.init = exports.withLogger = void 0;
+// Build-time Next.js config wrapper.
+var withLogger_1 = require("./withLogger");
+Object.defineProperty(exports, "withLogger", { enumerable: true, get: function () { return withLogger_1.withLogger; } });
+// Runtime initialisation + instance access.
+var init_1 = require("./init");
+Object.defineProperty(exports, "init", { enumerable: true, get: function () { return init_1.init; } });
+Object.defineProperty(exports, "getLogger", { enumerable: true, get: function () { return init_1.getLogger; } });
+// Logger + config internals.
 var logger_1 = require("./logger");
-Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
+Object.defineProperty(exports, "buildLogger", { enumerable: true, get: function () { return logger_1.buildLogger; } });
 var config_1 = require("./config");
 Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "resolveLoggerConfig", { enumerable: true, get: function () { return config_1.resolveLoggerConfig; } });
+Object.defineProperty(exports, "CONFIG_ENV_VAR", { enumerable: true, get: function () { return config_1.CONFIG_ENV_VAR; } });
 var defaults_1 = require("./defaults");
 Object.defineProperty(exports, "defaultConsolaOptions", { enumerable: true, get: function () { return defaults_1.defaultConsolaOptions; } });
 Object.defineProperty(exports, "resolveFormat", { enumerable: true, get: function () { return defaults_1.resolveFormat; } });
 // JSON reporter (server-side structured logging).
 var json_1 = require("./reporters/json");
 Object.defineProperty(exports, "createJsonReporter", { enumerable: true, get: function () { return json_1.createJsonReporter; } });
-// Patching API.
-var next_1 = require("./patches/next");
-Object.defineProperty(exports, "patchNext", { enumerable: true, get: function () { return next_1.patchNext; } });
-Object.defineProperty(exports, "routeNextMethod", { enumerable: true, get: function () { return next_1.routeNextMethod; } });
-Object.defineProperty(exports, "NEXT_PREFIXES", { enumerable: true, get: function () { return next_1.NEXT_PREFIXES; } });
+// Console-sink patch + Next-log classifier.
 var console_1 = require("./patches/console");
 Object.defineProperty(exports, "patchConsole", { enumerable: true, get: function () { return console_1.patchConsole; } });
 Object.defineProperty(exports, "routeConsoleMethod", { enumerable: true, get: function () { return console_1.routeConsoleMethod; } });
 Object.defineProperty(exports, "CONSOLE_METHODS", { enumerable: true, get: function () { return console_1.CONSOLE_METHODS; } });
+var next_1 = require("./patches/next");
+Object.defineProperty(exports, "isNextLog", { enumerable: true, get: function () { return next_1.isNextLog; } });
 var util_1 = require("./patches/util");
 Object.defineProperty(exports, "isEmptyMessage", { enumerable: true, get: function () { return util_1.isEmptyMessage; } });
 Object.defineProperty(exports, "skipEmpty", { enumerable: true, get: function () { return util_1.skipEmpty; } });

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;;;AAEH,yBAAuB;AAEvB,0BAA0B;AAC1B,mCAAkC;AAAzB,gGAAA,MAAM,OAAA;AACf,mCAAsC;AAA7B,oGAAA,UAAU,OAAA;AAEnB,uCAAkE;AAAzD,iHAAA,qBAAqB,OAAA;AAAE,yGAAA,aAAa,OAAA;AAG7C,kDAAkD;AAClD,yCAAsD;AAA7C,0GAAA,kBAAkB,OAAA;AAE3B,gBAAgB;AAChB,uCAA2E;AAAlE,iGAAA,SAAS,OAAA;AAAE,uGAAA,eAAe,OAAA;AAAE,qGAAA,aAAa,OAAA;AAElD,6CAAsF;AAA7E,uGAAA,YAAY,OAAA;AAAE,6GAAA,kBAAkB,OAAA;AAAE,0GAAA,eAAe,OAAA;AAE1D,uCAA2D;AAAlD,sGAAA,cAAc,OAAA;AAAE,iGAAA,SAAS,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;;;AAEH,qCAAqC;AACrC,2CAA0C;AAAjC,wGAAA,UAAU,OAAA;AAGnB,4CAA4C;AAC5C,+BAAyC;AAAhC,4FAAA,IAAI,OAAA;AAAE,iGAAA,SAAS,OAAA;AAGxB,6BAA6B;AAC7B,mCAAuC;AAA9B,qGAAA,WAAW,OAAA;AACpB,mCAA2E;AAAlE,oGAAA,UAAU,OAAA;AAAE,6GAAA,mBAAmB,OAAA;AAAE,wGAAA,cAAc,OAAA;AAExD,uCAAkE;AAAzD,iHAAA,qBAAqB,OAAA;AAAE,yGAAA,aAAa,OAAA;AAG7C,kDAAkD;AAClD,yCAAsD;AAA7C,0GAAA,kBAAkB,OAAA;AAE3B,4CAA4C;AAC5C,6CAAsF;AAA7E,uGAAA,YAAY,OAAA;AAAE,6GAAA,kBAAkB,OAAA;AAAE,0GAAA,eAAe,OAAA;AAE1D,uCAA2C;AAAlC,iGAAA,SAAS,OAAA;AAClB,uCAA2D;AAAlD,sGAAA,cAAc,OAAA;AAAE,iGAAA,SAAS,OAAA"}

package/dist/init.d.ts

@@ -0,0 +1,40 @@
+import type { ConsolaInstance } from "consola";
+/**
+ * Options for {@link init}.
+ */
+export interface InitOptions {
+    /**
+     * Patch the global `console.*` (default `true`). Set `false` to leave native
+     * `console` formatting untouched.
+     */
+    readonly console?: boolean;
+}
+/**
+ * Initialises `@vsfedorenko/next-logger`.
+ *
+ * Builds the shared consola instance from the `NEXT_LOGGER_CONFIG` env var
+ * (injected at build time by {@link withLogger}) and patches the global
+ * `console.*` so all diagnostic output — application logs AND Next.js' own
+ * internal logs — flows through one level-controllable sink. Call once from
+ * your `instrumentation.ts` `register()` hook:
+ *
+ * ```ts
+ * // instrumentation.ts (project root)
+ * export async function register() {
+ *   if (process.env.NEXT_RUNTIME === "nodejs") {
+ *     const { init } = await import("@vsfedorenko/next-logger");
+ *     init();
+ *   }
+ * }
+ * ```
+ *
+ * Returns the configured consola instance. Idempotent — a second call is a
+ * no-op that returns the existing instance.
+ */
+export declare function init(options?: InitOptions): ConsolaInstance;
+/**
+ * Returns the consola instance built by {@link init}. Throws if {@link init}
+ * has not been called yet.
+ */
+export declare function getLogger(): ConsolaInstance;
+//# sourceMappingURL=init.d.ts.map

package/dist/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI/C;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAID;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAgB,GAAG,eAAe,CAW/D;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,eAAe,CAO3C"}

package/dist/init.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports.getLogger = getLogger;
+const logger_1 = require("./logger");
+const console_1 = require("./patches/console");
+let active = null;
+/**
+ * Initialises `@vsfedorenko/next-logger`.
+ *
+ * Builds the shared consola instance from the `NEXT_LOGGER_CONFIG` env var
+ * (injected at build time by {@link withLogger}) and patches the global
+ * `console.*` so all diagnostic output — application logs AND Next.js' own
+ * internal logs — flows through one level-controllable sink. Call once from
+ * your `instrumentation.ts` `register()` hook:
+ *
+ * ```ts
+ * // instrumentation.ts (project root)
+ * export async function register() {
+ *   if (process.env.NEXT_RUNTIME === "nodejs") {
+ *     const { init } = await import("@vsfedorenko/next-logger");
+ *     init();
+ *   }
+ * }
+ * ```
+ *
+ * Returns the configured consola instance. Idempotent — a second call is a
+ * no-op that returns the existing instance.
+ */
+function init(options = {}) {
+    if (active)
+        return active;
+    const instance = (0, logger_1.buildLogger)();
+    active = instance;
+    if (options.console !== false) {
+        (0, console_1.patchConsole)(instance);
+    }
+    return instance;
+}
+/**
+ * Returns the consola instance built by {@link init}. Throws if {@link init}
+ * has not been called yet.
+ */
+function getLogger() {
+    if (!active) {
+        throw new Error("@vsfedorenko/next-logger: call init() before getLogger().");
+    }
+    return active;
+}
+//# sourceMappingURL=init.js.map

package/dist/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":";;AAuCA,oBAWC;AAMD,8BAOC;AA9DD,qCAAuC;AACvC,+CAAiD;AAajD,IAAI,MAAM,GAA2B,IAAI,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,IAAI,CAAC,UAAuB,EAAE;IAC5C,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAE1B,MAAM,QAAQ,GAAG,IAAA,oBAAW,GAAE,CAAC;IAC/B,MAAM,GAAG,QAAQ,CAAC;IAElB,IAAI,OAAO,CAAC,OAAO,KAAK,KAAK,EAAE,CAAC;QAC9B,IAAA,sBAAY,EAAC,QAAQ,CAAC,CAAC;IACzB,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;GAGG;AACH,SAAgB,SAAS;IACvB,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/logger.d.ts

@@ -1,21 +1,14 @@
 import { type ConsolaInstance } from "consola";
 /**
- * The shared consola instance backing all patches.
+ * Builds the shared consola instance from the resolved config.
  *
- * Resolution order:
- *   1. `next-logger.config.{ts,js,cjs,...}` → `consola` key is a
- *      {@link ConsolaInstance} or a factory → used directly.
- *   2. Same config → `consola` key is a partial options object → merged with
- *      defaults, then built.
- *   3. No config → built from {@link defaultConsolaOptions}.
+ * The config is delivered at build time by {@link withLogger} via the
+ * `NEXT_LOGGER_CONFIG` env var (see {@link loadConfig}). When `LOG_FORMAT=json`
+ * is set, the instance uses the {@link createJsonReporter} instead of consola's
+ * default pretty reporter. A custom instance/factory (only reachable when
+ * {@link loadConfig} is bypassed) is used as-is.
  *
- * When `LOG_FORMAT=json` (or `NEXT_PUBLIC_LOG_FORMAT=json`), the logger uses
- * the {@link createJsonReporter} instead of consola's default pretty reporter.
- * A config file's custom instance / factory bypasses format selection — the
- * user's instance controls everything.
- *
- * Both patches (`patches/next`, `patches/console`) call `.withTag()` on this
- * object so they can namespace their output.
+ * Call from {@link init} (the instrumentation hook).
  */
-export declare const logger: ConsolaInstance;
+export declare function buildLogger(): ConsolaInstance;
 //# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAK9D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,EAAE,eAA+B,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAK9D;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,IAAI,eAAe,CAkB7C"}

package/dist/logger.js

@@ -1,29 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
+exports.buildLogger = buildLogger;
 const consola_1 = require("consola");
 const config_1 = require("./config");
 const defaults_1 = require("./defaults");
 const json_1 = require("./reporters/json");
 /**
- * The shared consola instance backing all patches.
+ * Builds the shared consola instance from the resolved config.
  *
- * Resolution order:
- *   1. `next-logger.config.{ts,js,cjs,...}` → `consola` key is a
- *      {@link ConsolaInstance} or a factory → used directly.
- *   2. Same config → `consola` key is a partial options object → merged with
- *      defaults, then built.
- *   3. No config → built from {@link defaultConsolaOptions}.
+ * The config is delivered at build time by {@link withLogger} via the
+ * `NEXT_LOGGER_CONFIG` env var (see {@link loadConfig}). When `LOG_FORMAT=json`
+ * is set, the instance uses the {@link createJsonReporter} instead of consola's
+ * default pretty reporter. A custom instance/factory (only reachable when
+ * {@link loadConfig} is bypassed) is used as-is.
  *
- * When `LOG_FORMAT=json` (or `NEXT_PUBLIC_LOG_FORMAT=json`), the logger uses
- * the {@link createJsonReporter} instead of consola's default pretty reporter.
- * A config file's custom instance / factory bypasses format selection — the
- * user's instance controls everything.
- *
- * Both patches (`patches/next`, `patches/console`) call `.withTag()` on this
- * object so they can namespace their output.
+ * Call from {@link init} (the instrumentation hook).
  */
-exports.logger = buildLogger();
 function buildLogger() {
     const resolved = (0, config_1.loadConfig)();
     switch (resolved.kind) {

package/dist/logger.js.map

@@ -1 +1 @@
-{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":";;;AAAA,qCAA8D;AAC9D,qCAAsC;AACtC,yCAA2C;AAC3C,2CAAsD;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACU,QAAA,MAAM,GAAoB,WAAW,EAAE,CAAC;AAErD,SAAS,WAAW;IAClB,MAAM,QAAQ,GAAG,IAAA,mBAAU,GAAE,CAAC;IAE9B,QAAQ,QAAQ,CAAC,IAAI,EAAE,CAAC;QACtB,KAAK,UAAU;YACb,OAAO,QAAQ,CAAC,QAAQ,CAAC;QAC3B,KAAK,SAAS,CAAC,CAAC,CAAC;YACf,MAAM,QAAQ,GAAG,IAAA,uBAAa,EAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAEjD,wEAAwE;YACxE,kDAAkD;YAClD,IAAI,IAAA,wBAAa,GAAE,KAAK,MAAM,EAAE,CAAC;gBAC/B,QAAQ,CAAC,YAAY,CAAC,CAAC,IAAA,yBAAkB,GAAE,CAAC,CAAC,CAAC;YAChD,CAAC;YAED,OAAO,QAAQ,CAAC;QAClB,CAAC;IACH,CAAC;AACH,CAAC"}
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":";;AAgBA,kCAkBC;AAlCD,qCAA8D;AAC9D,qCAAsC;AACtC,yCAA2C;AAC3C,2CAAsD;AAEtD;;;;;;;;;;GAUG;AACH,SAAgB,WAAW;IACzB,MAAM,QAAQ,GAAG,IAAA,mBAAU,GAAE,CAAC;IAE9B,QAAQ,QAAQ,CAAC,IAAI,EAAE,CAAC;QACtB,KAAK,UAAU;YACb,OAAO,QAAQ,CAAC,QAAQ,CAAC;QAC3B,KAAK,SAAS,CAAC,CAAC,CAAC;YACf,MAAM,QAAQ,GAAG,IAAA,uBAAa,EAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAEjD,wEAAwE;YACxE,kDAAkD;YAClD,IAAI,IAAA,wBAAa,GAAE,KAAK,MAAM,EAAE,CAAC;gBAC/B,QAAQ,CAAC,YAAY,CAAC,CAAC,IAAA,yBAAkB,GAAE,CAAC,CAAC,CAAC;YAChD,CAAC;YAED,OAAO,QAAQ,CAAC;QAClB,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/patches/console.d.ts

@@ -1,12 +1,15 @@
 /**
  * Patches the global `console.*` methods so every call routes through the
- * shared consola instance tagged `console`.
+ * consola instance — the single interception point that captures BOTH
+ * application console output AND Next.js' internal logs (which `log.ts`
+ * funnels through `console.*`).
  *
- * This captures diagnostic output from third-party libraries and application
- * code that calls `console.log`/`console.error` directly — funnelling it
- * through the same level-controllable sink as Next's own logs.
+ * Each call is classified via {@link isNextLog}: lines carrying one of Next's
+ * marker symbols (`▲`/`✓`/`⚠`) are tagged `next.js`, everything else `console`.
+ * This restores the source distinction without monkeypatching Next's module
+ * (which Turbopack isolates into a separate bundle instance).
  *
- * This is a side-effect module — importing it applies the patch exactly once.
+ * Call explicitly via {@link init} — not a side-effect module.
  */
 import type { ConsolaInstance } from "consola";
 import type { LogFunction } from "../types";
@@ -17,22 +20,18 @@ export declare const CONSOLE_METHODS: readonly ["log", "debug", "info", "warn",
 /** A console method name we patch. */
 export type ConsoleMethodName = (typeof CONSOLE_METHODS)[number];
 /**
- * Maps a console method name to the corresponding consola log function.
+ * Maps a console method name to the corresponding consola log function bound
+ * to a child logger tagged `tag`. `console.log` and `console.info` both map to
+ * consola `info`. The result is wrapped in {@link skipEmpty}.
  *
- * `console.log` and `console.info` both map to consola `info` (matching the
- * original's behaviour). The returned function is bound to a child logger
- * tagged with `tag`, so every call is namespaced.
- *
- * Pure function — given a consola instance and a tag, returns the routing
- * function. Exported so the level mapping can be unit-tested without touching
- * the global `console`.
+ * Pure — exported so the routing can be unit-tested without touching the global
+ * `console`.
  */
 export declare function routeConsoleMethod(method: ConsoleMethodName | string, consola: ConsolaInstance, tag: string): LogFunction;
 /**
- * Applies the console patch. Overwrites `console.log`, `console.debug`,
- * `console.info`, `console.warn`, `console.error` with bound consola methods.
- *
- * @param tagOverride override the `console` tag (useful for tests).
+ * Overwrites `console.{log,debug,info,warn,error}` so calls route through the
+ * given consola instance, tagged `next.js` for Next's own log lines and
+ * `console` for everything else.
  */
-export declare function patchConsole(tagOverride?: string): void;
+export declare function patchConsole(consola: ConsolaInstance): void;
 //# sourceMappingURL=console.d.ts.map

package/dist/patches/console.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/patches/console.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG5C;;GAEG;AACH,eAAO,MAAM,eAAe,oDAMlB,CAAC;AAEX,sCAAsC;AACtC,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,iBAAiB,GAAG,MAAM,EAClC,OAAO,EAAE,eAAe,EACxB,GAAG,EAAE,MAAM,GACV,WAAW,CAKb;AAyBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAOvD"}
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/patches/console.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAI5C;;GAEG;AACH,eAAO,MAAM,eAAe,oDAMlB,CAAC;AAEX,sCAAsC;AACtC,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,iBAAiB,GAAG,MAAM,EAClC,OAAO,EAAE,eAAe,EACxB,GAAG,EAAE,MAAM,GACV,WAAW,CAGb;AAqBD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAO3D"}

package/dist/patches/console.js

@@ -1,19 +1,22 @@
 "use strict";
 /**
  * Patches the global `console.*` methods so every call routes through the
- * shared consola instance tagged `console`.
+ * consola instance — the single interception point that captures BOTH
+ * application console output AND Next.js' internal logs (which `log.ts`
+ * funnels through `console.*`).
  *
- * This captures diagnostic output from third-party libraries and application
- * code that calls `console.log`/`console.error` directly — funnelling it
- * through the same level-controllable sink as Next's own logs.
+ * Each call is classified via {@link isNextLog}: lines carrying one of Next's
+ * marker symbols (`▲`/`✓`/`⚠`) are tagged `next.js`, everything else `console`.
+ * This restores the source distinction without monkeypatching Next's module
+ * (which Turbopack isolates into a separate bundle instance).
  *
- * This is a side-effect module — importing it applies the patch exactly once.
+ * Call explicitly via {@link init} — not a side-effect module.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONSOLE_METHODS = void 0;
 exports.routeConsoleMethod = routeConsoleMethod;
 exports.patchConsole = patchConsole;
-const logger_1 = require("../logger");
+const next_1 = require("./next");
 const util_1 = require("./util");
 /**
  * The console methods this patch overwrites.
@@ -26,27 +29,17 @@ exports.CONSOLE_METHODS = [
     "error",
 ];
 /**
- * Maps a console method name to the corresponding consola log function.
+ * Maps a console method name to the corresponding consola log function bound
+ * to a child logger tagged `tag`. `console.log` and `console.info` both map to
+ * consola `info`. The result is wrapped in {@link skipEmpty}.
  *
- * `console.log` and `console.info` both map to consola `info` (matching the
- * original's behaviour). The returned function is bound to a child logger
- * tagged with `tag`, so every call is namespaced.
- *
- * Pure function — given a consola instance and a tag, returns the routing
- * function. Exported so the level mapping can be unit-tested without touching
- * the global `console`.
+ * Pure — exported so the routing can be unit-tested without touching the global
+ * `console`.
  */
 function routeConsoleMethod(method, consola, tag) {
     const child = consola.withTag(tag);
-    const bound = selectConsolaMethod(method, child);
-    return (0, util_1.skipEmpty)(bound);
+    return (0, util_1.skipEmpty)(selectConsolaMethod(method, child));
 }
-/**
- * Selects the consola method matching a console method name.
- *
- * The bound function is returned directly; consola's methods accept the same
- * `(...args: unknown[])` shape as {@link LogFunction}.
- */
 function selectConsolaMethod(method, consola) {
     switch (method) {
         case "error":
@@ -59,24 +52,20 @@ function selectConsolaMethod(method, consola) {
         case "info":
             return consola.info.bind(consola);
         default:
-            // Unknown method name — default to info (same as the original).
             return consola.info.bind(consola);
     }
 }
 /**
- * Applies the console patch. Overwrites `console.log`, `console.debug`,
- * `console.info`, `console.warn`, `console.error` with bound consola methods.
- *
- * @param tagOverride override the `console` tag (useful for tests).
+ * Overwrites `console.{log,debug,info,warn,error}` so calls route through the
+ * given consola instance, tagged `next.js` for Next's own log lines and
+ * `console` for everything else.
  */
-function patchConsole(tagOverride) {
-    const tag = tagOverride ?? "console";
+function patchConsole(consola) {
     for (const method of exports.CONSOLE_METHODS) {
-        const routed = routeConsoleMethod(method, logger_1.logger, tag);
-        console[method] = routed;
+        console[method] = ((...args) => {
+            const tag = (0, next_1.isNextLog)(args) ? "next.js" : "console";
+            routeConsoleMethod(method, consola, tag)(...args);
+        });
     }
 }
-// Apply on import (side effect), matching the original's
-// `require('./patches/console')` semantics.
-patchConsole();
 //# sourceMappingURL=console.js.map

package/dist/patches/console.js.map

@@ -1 +1 @@
-{"version":3,"file":"console.js","sourceRoot":"","sources":["../../src/patches/console.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAgCH,gDASC;AA+BD,oCAOC;AA5ED,sCAAmC;AAEnC,iCAAmC;AAEnC;;GAEG;AACU,QAAA,eAAe,GAAG;IAC7B,KAAK;IACL,OAAO;IACP,MAAM;IACN,MAAM;IACN,OAAO;CACC,CAAC;AAKX;;;;;;;;;;GAUG;AACH,SAAgB,kBAAkB,CAChC,MAAkC,EAClC,OAAwB,EACxB,GAAW;IAEX,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAEnC,MAAM,KAAK,GAAgB,mBAAmB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC9D,OAAO,IAAA,gBAAS,EAAC,KAAK,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,MAAc,EAAE,OAAwB;IACnE,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,OAAO;YACV,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACpD,KAAK,MAAM;YACT,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACnD,KAAK,OAAO;YACV,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACpD,KAAK,KAAK,CAAC;QACX,KAAK,MAAM;YACT,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACnD;YACE,gEAAgE;YAChE,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;IACrD,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAgB,YAAY,CAAC,WAAoB;IAC/C,MAAM,GAAG,GAAG,WAAW,IAAI,SAAS,CAAC;IAErC,KAAK,MAAM,MAAM,IAAI,uBAAe,EAAE,CAAC;QACrC,MAAM,MAAM,GAAG,kBAAkB,CAAC,MAAM,EAAE,eAAM,EAAE,GAAG,CAAC,CAAC;QACvD,OAAO,CAAC,MAAM,CAAC,GAAG,MAAoC,CAAC;IACzD,CAAC;AACH,CAAC;AAED,yDAAyD;AACzD,4CAA4C;AAC5C,YAAY,EAAE,CAAC"}
+{"version":3,"file":"console.js","sourceRoot":"","sources":["../../src/patches/console.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AA6BH,gDAOC;AA0BD,oCAOC;AAjED,iCAAmC;AACnC,iCAAmC;AAEnC;;GAEG;AACU,QAAA,eAAe,GAAG;IAC7B,KAAK;IACL,OAAO;IACP,MAAM;IACN,MAAM;IACN,OAAO;CACC,CAAC;AAKX;;;;;;;GAOG;AACH,SAAgB,kBAAkB,CAChC,MAAkC,EAClC,OAAwB,EACxB,GAAW;IAEX,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACnC,OAAO,IAAA,gBAAS,EAAC,mBAAmB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;AACvD,CAAC;AAED,SAAS,mBAAmB,CAC1B,MAAc,EACd,OAAwB;IAExB,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,OAAO;YACV,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACpD,KAAK,MAAM;YACT,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACnD,KAAK,OAAO;YACV,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACpD,KAAK,KAAK,CAAC;QACX,KAAK,MAAM;YACT,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACnD;YACE,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;IACrD,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,OAAwB;IACnD,KAAK,MAAM,MAAM,IAAI,uBAAe,EAAE,CAAC;QACrC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,IAAe,EAAE,EAAE;YACxC,MAAM,GAAG,GAAG,IAAA,gBAAS,EAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;YACpD,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QACpD,CAAC,CAA+B,CAAC;IACnC,CAAC;AACH,CAAC"}

package/dist/patches/next.d.ts

@@ -1,42 +1,17 @@
 /**
- * Patches Next.js' internal logger (`next/dist/build/output/log`) so every
- * call routes through the shared consola instance tagged `next.js`.
+ * Classifier for Next.js' internal log output captured at the console sink.
  *
- * Next 13+ defines its logger exports as non-configurable accessor properties,
- * which would throw under a plain redefinition. We work around this by
- * replacing `require.cache[...].exports` with a shallow copy (the original's
- * approach), then defining each method as a plain value property on the copy.
- *
- * This is a side-effect module — importing it applies the patch exactly once.
- */
-import type { ConsolaInstance } from "consola";
-import type { LogFunction } from "../types";
-/**
- * The methods exported by Next's log module that we patch.
- *
- * `prefixes` is the set Next itself advertises (wait/error/warn/ready/info/
- * event/trace). `bootstrap` is an extra export that bypasses the prefix logic
- * (raw `console.log`) — we route it too so it stays consistent.
+ * Next.js' `next/dist/build/output/log` funnels every diagnostic line through
+ * `console.log`/`console.warn`/`console.error`, prefixing each with a coloured
+ * marker symbol (`▲`, `✓`, `⚠`, …). Detecting that prefix lets the console
+ * patch tag those lines as `next.js` rather than `console` — restoring the
+ * source distinction WITHOUT monkeypatching Next's module (which is isolated
+ * into a separate bundle instance under Turbopack and unreachable via
+ * `require.cache`).
  */
-export declare const NEXT_PREFIXES: readonly ["wait", "error", "warn", "ready", "info", "event", "trace"];
-/** A Next.js prefix method name we patch. */
-export type NextMethodName = (typeof NEXT_PREFIXES)[number];
 /**
- * Maps a Next.js prefix name to the corresponding consola log function.
- * `trace` maps to consola's native `trace` — no fallback needed (consola has
- * it; the pino original had to fall back to `debug` for Winston which lacks
- * trace).
- *
- * Pure function — given a consola instance and a tag, returns the routing
- * function. Exported so the level mapping can be unit-tested without touching
- * `require.cache` or a real Next.js install.
- */
-export declare function routeNextMethod(method: NextMethodName | string, consola: ConsolaInstance, tag: string): LogFunction;
-/**
- * Applies the Next.js logger patch. Safe to call multiple times — it
- * re-derives the methods from the current {@link logger} each time.
- *
- * @param tagOverride override the `next.js` tag (useful for tests).
+ * Returns `true` when the given console call args look like a Next.js log line
+ * (first string arg, ANSI-stripped, starts with a Next marker symbol).
  */
-export declare function patchNext(tagOverride?: string): void;
+export declare function isNextLog(args: readonly unknown[]): boolean;
 //# sourceMappingURL=next.d.ts.map

package/dist/patches/next.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../../src/patches/next.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,UAAU,CAAC;AAG3D;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,uEAQhB,CAAC;AAEX,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,cAAc,GAAG,MAAM,EAC/B,OAAO,EAAE,eAAe,EACxB,GAAG,EAAE,MAAM,GACV,WAAW,CAKb;AAmBD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAuCpD"}
+{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../../src/patches/next.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAWH;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAK3D"}