@visulima/pail 4.0.0-alpha.1 → 4.0.0-alpha.10

package/dist/packem_shared/{index-BomQ3E6J.js → index-Bx3-C0j9.js}

@@ -1,3 +1,11 @@
+const getLongestLabel = (types) => {
+  const labels = Object.keys(types).map((x) => types[x].label ?? "");
+  if (labels.length === 0) {
+    return "";
+  }
+  return labels.reduce((x, y) => x.length > y.length ? x : y, "");
+};
+
 const colorKeywords = /* @__PURE__ */ new Map([
   ["aliceblue", "#f0f8ff"],
   ["antiquewhite", "#faebd7"],
@@ -163,7 +171,7 @@ const getDefaultCss = () => {
     textDecorationLine: []
   };
 };
-const SPACE_PATTERN = /\s+/g;
+const SPACE_PATTERN = /\s+/;
 const parseCssColor = (colorString) => {
   if (colorKeywords.has(colorString)) {
     colorString = colorKeywords.get(colorString);
@@ -229,10 +237,10 @@ const parseCss = (cssString) => {
   let currentPart = "";
   for (const c of cssString) {
     if (c === "(") {
-      parenthesesDepth++;
+      parenthesesDepth += 1;
     } else if (parenthesesDepth > 0) {
       if (c === ")") {
-        parenthesesDepth--;
+        parenthesesDepth -= 1;
       }
     } else if (inValue) {
       if (c === ";") {
@@ -365,14 +373,14 @@ const cssToAnsi = (css, previousCss = null) => {
         default: {
           if (Array.isArray(css.backgroundColor)) {
             const { 0: r, 1: g, 2: b } = css.backgroundColor;
-            ansi += `\x1B[48;2;${r};${g};${b}m`;
+            ansi += `\x1B[48;2;${String(r)};${String(g)};${String(b)}m`;
           } else {
             const parsed = parseCssColor(css.backgroundColor);
             if (parsed === null) {
               ansi += "\x1B[49m";
             } else {
               const { 0: r, 1: g, 2: b } = parsed;
-              ansi += `\x1B[48;2;${r};${g};${b}m`;
+              ansi += `\x1B[48;2;${String(r)};${String(g)};${String(b)}m`;
             }
           }
         }
@@ -419,14 +427,14 @@ const cssToAnsi = (css, previousCss = null) => {
         default: {
           if (Array.isArray(css.color)) {
             const { 0: r, 1: g, 2: b } = css.color;
-            ansi += `\x1B[38;2;${r};${g};${b}m`;
+            ansi += `\x1B[38;2;${String(r)};${String(g)};${String(b)}m`;
           } else {
             const parsed = parseCssColor(css.color);
             if (parsed === null) {
               ansi += "\x1B[39m";
             } else {
               const { 0: r, 1: g, 2: b } = parsed;
-              ansi += `\x1B[38;2;${r};${g};${b}m`;
+              ansi += `\x1B[38;2;${String(r)};${String(g)};${String(b)}m`;
             }
           }
         }
@@ -444,7 +452,7 @@ const cssToAnsi = (css, previousCss = null) => {
       ansi += "\x1B[59m";
     } else {
       const { 0: r, 1: g, 2: b } = css.textDecorationColor;
-      ansi += `\x1B[58;2;${r};${g};${b}m`;
+      ansi += `\x1B[58;2;${String(r)};${String(g)};${String(b)}m`;
     }
   }
   if (css.textDecorationLine.includes("line-through") !== previousCss.textDecorationLine.includes("line-through")) {
@@ -487,7 +495,7 @@ const format = (fmt, arguments_ = [], options = {}) => {
     }
     const objects = Array.from({ length: argumentsLength });
     objects[0] = stringify(fmt);
-    for (let index = 1; index < argumentsLength; index++) {
+    for (let index = 1; index < argumentsLength; index += 1) {
       objects[index] = stringify(arguments_[index - offset]);
     }
     return objects.join(" ");
@@ -505,7 +513,7 @@ const format = (fmt, arguments_ = [], options = {}) => {
       lastPosition = lastPosition > -1 ? lastPosition : 0;
       const c = fmt.codePointAt(index + 1);
       if (c === void 0) {
-        ++a;
+        a += 1;
         break;
       }
       switch (c) {
@@ -522,7 +530,7 @@ const format = (fmt, arguments_ = [], options = {}) => {
             }
           }
           lastPosition = index + 2;
-          index++;
+          index += 1;
           break;
         }
         case CHAR_d:
@@ -535,7 +543,7 @@ const format = (fmt, arguments_ = [], options = {}) => {
           }
           result += Number(arguments_[a]).toString();
           lastPosition = index + 2;
-          index++;
+          index += 1;
           break;
         }
         case CHAR_i: {
@@ -547,7 +555,7 @@ const format = (fmt, arguments_ = [], options = {}) => {
           }
           result += Math.floor(Number(arguments_[a])).toString();
           lastPosition = index + 2;
-          index++;
+          index += 1;
           break;
         }
         case CHAR_j:
@@ -573,7 +581,7 @@ const format = (fmt, arguments_ = [], options = {}) => {
           }
           result += stringify(temporaryArgument);
           lastPosition = index + 2;
-          index++;
+          index += 1;
           break;
         }
         case CHAR_PERCENT: {
@@ -582,8 +590,8 @@ const format = (fmt, arguments_ = [], options = {}) => {
           }
           result += "%";
           lastPosition = index + 2;
-          index++;
-          a--;
+          index += 1;
+          a -= 1;
           break;
         }
         case CHAR_s: {
@@ -595,7 +603,7 @@ const format = (fmt, arguments_ = [], options = {}) => {
           }
           result += typeof arguments_[a] === "object" ? stringify(arguments_[a]) : String(arguments_[a]);
           lastPosition = index + 2;
-          index++;
+          index += 1;
           break;
         }
         default: {
@@ -605,13 +613,13 @@ const format = (fmt, arguments_ = [], options = {}) => {
             }
             result += options.formatters[c](arguments_[a]);
             lastPosition = index + 2;
-            index++;
+            index += 1;
           }
         }
       }
-      ++a;
+      a += 1;
     }
-    ++index;
+    index += 1;
   }
   if (lastPosition === -1) {
     return fmt;
@@ -647,4 +655,4 @@ const build = (options = {}) => {
   return (f, arguments_ = [], formatOptions = {}) => format(f, arguments_, { ...formatOptions, formatters });
 };
 
-export { build as b, format as f };
+export { build as b, format as f, getLongestLabel as g };

package/dist/packem_shared/pailMiddleware-Ci88geIF.js

@@ -0,0 +1,24 @@
+const GLOB_STRIP_RE = /\*+/g;
+const pailMiddleware = (NextResponseClass, options) => {
+  const { exclude, include } = options ?? {};
+  return (request) => {
+    const path = request.nextUrl.pathname;
+    if (exclude?.some((p) => path.startsWith(p.replaceAll(GLOB_STRIP_RE, "")))) {
+      return NextResponseClass.next();
+    }
+    if (include?.length && !include.some((p) => path.startsWith(p.replaceAll(GLOB_STRIP_RE, "")))) {
+      return NextResponseClass.next();
+    }
+    const requestId = request.headers.get("x-request-id") ?? crypto.randomUUID();
+    const requestHeaders = new Headers(request.headers);
+    requestHeaders.set("x-request-id", requestId);
+    requestHeaders.set("x-pail-start", String(Date.now()));
+    const response = NextResponseClass.next({
+      request: { headers: requestHeaders }
+    });
+    response.headers.set("x-request-id", requestId);
+    return response;
+  };
+};
+
+export { pailMiddleware };

package/dist/packem_shared/storage-D0vqz8OX.js

@@ -0,0 +1,36 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  AsyncLocalStorage
+} = __cjs_getBuiltinModule("node:async_hooks");
+
+const createLoggerStorage = (contextHint) => {
+  const storage = new AsyncLocalStorage();
+  const useLogger = () => {
+    const logger = storage.getStore();
+    if (!logger) {
+      throw new Error(`[pail] useLogger() called outside of ${contextHint}`);
+    }
+    return logger;
+  };
+  return { storage, useLogger };
+};
+
+export { createLoggerStorage as c };

package/dist/packem_shared/{InteractiveStreamHook-DiSubbJ1.js → useLogger-D0rU3lcX.js}

@@ -17,5 +17,17 @@ const __cjs_getBuiltinModule = (module) => {
     return __cjs_require(module);
 };
 
+const {
+  AsyncLocalStorage
+} = __cjs_getBuiltinModule("node:async_hooks");
 
-export { I as default } from './interactive-stream-hook-DG4BtN12.js';
+const pailStorage = new AsyncLocalStorage();
+const useLogger = () => {
+  const logger = pailStorage.getStore();
+  if (!logger) {
+    throw new Error("[pail] useLogger() called outside of withPail() context. Wrap your route handler or server action with withPail().");
+  }
+  return logger;
+};
+
+export { pailStorage, useLogger };

package/dist/packem_shared/{write-console-log-based-on-level-DBmRYXpj.js → write-console-log-based-on-level-ree2lDPw.js}

@@ -1,14 +1,15 @@
 const writeConsoleLogBasedOnLevel = (level) => {
+  const c = console;
   if (level === "error") {
-    return console.__error ?? console.error;
+    return c.__error ?? console.error;
   }
   if (level === "warn") {
-    return console.__warn ?? console.warn;
+    return c.__warn ?? console.warn;
   }
   if (level === "trace") {
-    return console.__trace ?? console.trace;
+    return c.__trace ?? console.trace;
   }
-  return console.__log ?? console.log;
+  return c.__log ?? console.log;
 };
 
 export { writeConsoleLogBasedOnLevel as w };

package/dist/packem_shared/{write-stream-BG8fhcs3.js → write-stream-BuFtjATz.js}

@@ -1,5 +1,5 @@
 const writeStream = (data, stream) => {
-  const write = stream.__write ?? stream.write;
+  const write = stream.__write ?? stream.write.bind(stream);
   return write.call(stream, data);
 };
 

package/dist/pail.browser.d.ts

@@ -403,7 +403,7 @@ export declare class PailBrowserImpl<T extends string = string, L extends string
     protected extendReporter(reporter: Reporter<L>): Reporter<L>;
     protected registerReporters(reporters: Reporter<L>[]): void;
     protected registerProcessors(processors: Processor<L>[]): void;
-    protected logger(type: LiteralUnion<DefaultLogTypes, T>, raw: boolean, force: boolean, ...messageObject: any[]): void;
+    protected logger(type: LiteralUnion<DefaultLogTypes, T>, raw: boolean, force: boolean, ...messageObject: unknown[]): void;
 }
 export type PailBrowserType<T extends string = string, L extends string = string> = Console & (new <TC extends string = string, LC extends string = string>(options?: ConstructorOptions<TC, LC>) => PailBrowserType<TC, LC>) & PailBrowserImpl<T, L> & Record<DefaultLogTypes, LoggerFunction> & Record<T, LoggerFunction> & {
     force: Record<DefaultLogTypes, LoggerFunction> & Record<T, LoggerFunction>;

package/dist/processor/environment-processor.d.ts

@@ -0,0 +1,124 @@
+import type { Meta, Processor } from "../types.d.ts";
+/**
+ * Detected environment information.
+ *
+ * Contains runtime environment details that are automatically detected
+ * from environment variables and process information.
+ */
+interface EnvironmentInfo {
+    /** Git commit hash or short SHA */
+    commit?: string;
+    /** Runtime environment (e.g., "production", "development", "test") */
+    environment?: string;
+    /** Hostname of the machine */
+    hostname?: string;
+    /** Process ID */
+    pid?: number;
+    /** Cloud region (e.g., "us-east-1") */
+    region?: string;
+    /** Application/service name */
+    service?: string;
+    /** Application version */
+    version?: string;
+}
+/**
+ * Environment processor configuration options.
+ */
+interface EnvironmentProcessorOptions {
+    /**
+     * Whether to include the hostname. Defaults to false.
+     */
+    includeHostname?: boolean;
+    /**
+     * Whether to include the process ID. Defaults to false.
+     */
+    includePid?: boolean;
+    /**
+     * Static environment info to use instead of or in addition to auto-detection.
+     * Values provided here take precedence over auto-detected values.
+     */
+    overrides?: Partial<EnvironmentInfo>;
+}
+/**
+ * Detects the runtime environment from environment variables.
+ *
+ * Checks common environment variable patterns used by various hosting
+ * platforms (Vercel, AWS, GCP, Heroku, Railway, Fly.io, Render, etc.)
+ * to automatically determine service name, version, environment, region,
+ * and commit hash.
+ * @returns Detected environment information
+ */
+declare const detectEnvironment: () => EnvironmentInfo;
+/**
+ * Environment Enrichment Processor.
+ *
+ * Inspired by evlog's automatic environment detection, this processor
+ * enriches log metadata with runtime environment information. It auto-detects
+ * details like service name, version, environment, region, and commit hash
+ * from common environment variables used by popular hosting platforms.
+ *
+ * The detected info is added to the log's context, making it easier to
+ * correlate logs across services and deployments in production.
+ * @template L - The log level type
+ * @example
+ * ```typescript
+ * import { createPail } from "@visulima/pail";
+ * import EnvironmentProcessor from "@visulima/pail/processor/environment";
+ *
+ * const logger = createPail({
+ *   processors: [
+ *     new EnvironmentProcessor({
+ *       overrides: { service: "my-api" },
+ *       includePid: true,
+ *     }),
+ *   ],
+ * });
+ *
+ * logger.info("Server started");
+ * // Log metadata will include: { __env: { service: "my-api", environment: "production", ... } }
+ * ```
+ * @example
+ * ```typescript
+ * // With static configuration only (no auto-detection)
+ * new EnvironmentProcessor({
+ *   overrides: {
+ *     service: "payment-service",
+ *     version: "2.1.0",
+ *     environment: "staging",
+ *   },
+ * });
+ * ```
+ */
+declare class EnvironmentProcessor<L extends string = string> implements Processor<L> {
+    #private;
+    /**
+     * Creates a new EnvironmentProcessor instance.
+     *
+     * Auto-detects environment information on construction and merges
+     * with any provided overrides. Undefined values in overrides are
+     * filtered out so they don't overwrite detected values.
+     * @param options Processor configuration options
+     */
+    constructor(options?: EnvironmentProcessorOptions);
+    /**
+     * Processes log metadata to add environment information.
+     *
+     * Adds a `__env` property to the meta containing detected and
+     * configured environment details. Each call receives a shallow
+     * clone of the environment info to prevent cross-record mutation.
+     * @param meta The log metadata to process
+     * @returns The processed metadata with environment info added
+     */
+    process(meta: Meta<L>): Meta<L>;
+    /**
+     * Returns the detected environment information.
+     *
+     * Useful for inspecting what environment details were auto-detected.
+     * Returns a shallow clone to prevent external mutation.
+     * @returns The environment information object
+     */
+    getEnvironmentInfo(): Readonly<EnvironmentInfo>;
+}
+export { detectEnvironment };
+export default EnvironmentProcessor;
+export type { EnvironmentInfo, EnvironmentProcessorOptions };

package/dist/processor/environment-processor.js

@@ -0,0 +1,82 @@
+const detectEnvironment = () => {
+  if (!process.env) {
+    return {};
+  }
+  const { env } = process;
+  const info = {
+    /* eslint-disable @typescript-eslint/no-unnecessary-condition, @typescript-eslint/prefer-nullish-coalescing -- env vars may be undefined or empty at runtime */
+    // Commit hash
+    commit: env.COMMIT_SHA || env.GIT_COMMIT || env.VERCEL_GIT_COMMIT_SHA?.slice(0, 7) || env.RAILWAY_GIT_COMMIT_SHA?.slice(0, 7) || env.RENDER_GIT_COMMIT?.slice(0, 7) || env.HEROKU_SLUG_COMMIT?.slice(0, 7) || env.CF_PAGES_COMMIT_SHA?.slice(0, 7) || void 0,
+    // Environment / Node env
+    environment: env.NODE_ENV || env.ENVIRONMENT || env.APP_ENV || void 0,
+    // Hostname
+    hostname: env.HOSTNAME || env.HOST || void 0,
+    // PID
+    pid: process.pid,
+    // Region (including GCP Cloud Functions FUNCTION_REGION and GOOGLE_CLOUD_REGION)
+    region: env.AWS_REGION || env.VERCEL_REGION || env.FLY_REGION || env.RENDER_REGION || env.CF_REGION || env.GOOGLE_CLOUD_REGION || env.FUNCTION_REGION || void 0,
+    // Service name - check common platform variables (including GCP Cloud Run / App Engine)
+    service: env.SERVICE_NAME || env.APP_NAME || env.K_SERVICE || env.GAE_SERVICE || env.FUNCTION_TARGET || env.VERCEL_PROJECT_PRODUCTION_URL || env.FLY_APP_NAME || env.RAILWAY_SERVICE_NAME || env.RENDER_SERVICE_NAME || env.HEROKU_APP_NAME || void 0,
+    // Version (including GCP Cloud Run K_REVISION and App Engine GAE_VERSION)
+    version: env.APP_VERSION || env.npm_package_version || env.K_REVISION || env.GAE_VERSION || env.RAILWAY_GIT_COMMIT_SHA?.slice(0, 7) || env.RENDER_GIT_COMMIT?.slice(0, 7) || void 0
+    /* eslint-enable @typescript-eslint/no-unnecessary-condition, @typescript-eslint/prefer-nullish-coalescing */
+  };
+  return Object.fromEntries(Object.entries(info).filter(([, v]) => v !== void 0));
+};
+class EnvironmentProcessor {
+  #envInfo;
+  /**
+   * Creates a new EnvironmentProcessor instance.
+   *
+   * Auto-detects environment information on construction and merges
+   * with any provided overrides. Undefined values in overrides are
+   * filtered out so they don't overwrite detected values.
+   * @param options Processor configuration options
+   */
+  constructor(options = {}) {
+    const detected = detectEnvironment();
+    const cleanOverrides = {};
+    if (options.overrides) {
+      const overrideEntries = Object.entries(options.overrides);
+      for (let i = 0; i < overrideEntries.length; i += 1) {
+        const [key, value] = overrideEntries[i];
+        if (value !== void 0) {
+          cleanOverrides[key] = value;
+        }
+      }
+    }
+    const merged = { ...detected, ...cleanOverrides };
+    if (!options.includePid && cleanOverrides.pid === void 0) {
+      delete merged.pid;
+    }
+    if (!options.includeHostname && cleanOverrides.hostname === void 0) {
+      delete merged.hostname;
+    }
+    this.#envInfo = merged;
+  }
+  /**
+   * Processes log metadata to add environment information.
+   *
+   * Adds a `__env` property to the meta containing detected and
+   * configured environment details. Each call receives a shallow
+   * clone of the environment info to prevent cross-record mutation.
+   * @param meta The log metadata to process
+   * @returns The processed metadata with environment info added
+   */
+  process(meta) {
+    const enriched = { ...meta, envStorage: { ...this.#envInfo } };
+    return enriched;
+  }
+  /**
+   * Returns the detected environment information.
+   *
+   * Useful for inspecting what environment details were auto-detected.
+   * Returns a shallow clone to prevent external mutation.
+   * @returns The environment information object
+   */
+  getEnvironmentInfo() {
+    return { ...this.#envInfo };
+  }
+}
+
+export { EnvironmentProcessor as default, detectEnvironment };

package/dist/processor/message-formatter-processor.d.ts

@@ -1,10 +1,9 @@
 import type { FormatterFunction } from "@visulima/fmt";
-import type { stringify } from "safe-stable-stringify";
 import type { Meta, StringifyAwareProcessor } from "../types.d.ts";
 /**
  * Message Formatter Processor.
  *
- * A processor that formats log messages using the {@link https://www.visulima.com/docs/package/fmt|@visulima/fmt} library.
+ * A processor that formats log messages using the {@link https://visulima.com/packages/fmt/|@visulima/fmt} library.
  * Supports custom formatters, string interpolation, and complex object formatting.
  * Processes both the main message and contextual data.
  * @template L - The log level type
@@ -39,7 +38,7 @@ declare class MessageFormatterProcessor<L extends string = string> implements St
      * Sets the stringify function for object serialization.
      * @param function_ The stringify function to use for serializing objects
      */
-    setStringify(function_: typeof stringify): void;
+    setStringify(function_: typeof JSON.stringify): void;
     /**
      * Processes log metadata to format messages.
      *