@spinajs/log 2.0.481 → 2.0.482

package/lib/cjs/perf/measure.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Measure = Measure;
+const log_common_1 = require("@spinajs/log-common");
+/**
+ * Method decorator that times the wrapped method via {@link Perf.measure}. Name
+ * defaults to `${ClassName}.${method}`. Works for sync and async methods ( the
+ * facade awaits a returned thenable ). Uses the same legacy-decorator signature
+ * as the rest of the framework ( `experimentalDecorators` ).
+ */
+function Measure(name, opts) {
+    return function (target, propertyKey, descriptor) {
+        const original = descriptor.value;
+        const metricName = name ?? `${target.constructor.name}.${String(propertyKey)}`;
+        descriptor.value = function (...args) {
+            return log_common_1.Perf.measure(metricName, () => original.apply(this, args), opts);
+        };
+        return descriptor;
+    };
+}
+//# sourceMappingURL=measure.js.map

package/lib/cjs/perf/measure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure.js","sourceRoot":"","sources":["../../../src/perf/measure.ts"],"names":[],"mappings":";;AAQA,0BASC;AAjBD,oDAAyD;AAEzD;;;;;GAKG;AACH,SAAgB,OAAO,CAAC,IAAa,EAAE,IAAmB;IACxD,OAAO,UAAU,MAAc,EAAE,WAA4B,EAAE,UAA8B;QAC3F,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAwC,CAAC;QACrE,MAAM,UAAU,GAAG,IAAI,IAAI,GAAI,MAA4C,CAAC,WAAW,CAAC,IAAI,IAAI,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QACtH,UAAU,CAAC,KAAK,GAAG,UAAyB,GAAG,IAAe;YAC5D,OAAO,iBAAI,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;QAC1E,CAAC,CAAC;QACF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC"}

package/lib/cjs/perf.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Install the per-request perf-scope backend for the node runtime. Reads the
+ * `perf` accumulator off the ambient async store ( which IS `req.storage` when
+ * http runs an action, so the scope created by the http PerfRollup middleware
+ * and mutated during the action is one and the same object ). Called from
+ * {@link LogBotstrapper.bootstrap}.
+ */
+export declare function wirePerfScope(): void;
+//# sourceMappingURL=perf.d.ts.map

package/lib/cjs/perf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf.d.ts","sourceRoot":"","sources":["../../src/perf.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAIpC"}

package/lib/cjs/perf.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wirePerfScope = wirePerfScope;
+const log_common_1 = require("@spinajs/log-common");
+const context_js_1 = require("./context.js");
+/**
+ * Install the per-request perf-scope backend for the node runtime. Reads the
+ * `perf` accumulator off the ambient async store ( which IS `req.storage` when
+ * http runs an action, so the scope created by the http PerfRollup middleware
+ * and mutated during the action is one and the same object ). Called from
+ * {@link LogBotstrapper.bootstrap}.
+ */
+function wirePerfScope() {
+    (0, log_common_1.setPerfScopeBackend)({
+        get: () => context_js_1.LogContext.active().perf ?? null,
+    });
+}
+//# sourceMappingURL=perf.js.map

package/lib/cjs/perf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf.js","sourceRoot":"","sources":["../../src/perf.ts"],"names":[],"mappings":";;AAUA,sCAIC;AAdD,oDAAsE;AACtE,6CAA0C;AAE1C;;;;;;GAMG;AACH,SAAgB,aAAa;IAC3B,IAAA,gCAAmB,EAAC;QAClB,GAAG,EAAE,GAAG,EAAE,CAAE,uBAAU,CAAC,MAAM,EAAE,CAAC,IAA+B,IAAI,IAAI;KACxE,CAAC,CAAC;AACL,CAAC"}

package/lib/cjs/schemas/log.configuration.d.ts

@@ -24,29 +24,153 @@ declare const CONFIGURATION_SCHEMA: {
                     enabled: {
                         type: string;
                     };
-                    path: {
-                        type: string;
-                    };
-                    archivePath: {
-                        type: string;
-                    };
-                    maxSize: {
-                        type: string;
-                        minimum: number;
-                    };
-                    compress: {
-                        type: string;
-                    };
-                    rotate: {
+                    filters: {
+                        description: string;
                         type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                type: {
+                                    description: string;
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                        };
                     };
-                    maxArchiveFiles: {
+                    options: {
                         type: string;
-                        minimum: number;
+                        properties: {
+                            path: {
+                                description: string;
+                                type: string;
+                            };
+                            archivePath: {
+                                description: string;
+                                type: string;
+                            };
+                            fs: {
+                                description: string;
+                                type: string;
+                            };
+                            archiveFs: {
+                                description: string;
+                                type: string;
+                            };
+                            archiveStrategy: {
+                                description: string;
+                                type: string;
+                            };
+                            retentionStrategies: {
+                                description: string;
+                                type: string;
+                                items: {
+                                    type: string;
+                                };
+                            };
+                            maxSize: {
+                                description: string;
+                                type: string;
+                                minimum: number;
+                            };
+                            compress: {
+                                description: string;
+                                type: string;
+                            };
+                            rotate: {
+                                description: string;
+                                type: string;
+                            };
+                            maxBufferSize: {
+                                description: string;
+                                type: string;
+                                minimum: number;
+                            };
+                            maxQueueSize: {
+                                description: string;
+                                type: string;
+                                minimum: number;
+                            };
+                            maxArchiveFiles: {
+                                description: string;
+                                type: string;
+                                minimum: number;
+                            };
+                            maxAge: {
+                                description: string;
+                                type: string;
+                                minimum: number;
+                            };
+                            archiveInterval: {
+                                description: string;
+                                type: string;
+                                minimum: number;
+                            };
+                            flushInterval: {
+                                description: string;
+                                type: string;
+                                minimum: number;
+                            };
+                        };
+                        required: string[];
                     };
-                    bufferSize: {
+                };
+                required: string[];
+            };
+        };
+        file: {
+            description: string;
+            type: string;
+        };
+        perf: {
+            description: string;
+            type: string;
+            properties: {
+                enabled: {
+                    type: string;
+                };
+                thresholds: {
+                    description: string;
+                    type: string;
+                };
+                overThresholdLevel: {
+                    type: string;
+                    enum: string[];
+                };
+                underThresholdLevel: {
+                    type: string;
+                    enum: string[];
+                };
+                logCounters: {
+                    type: string;
+                };
+            };
+        };
+        whenRepeated: {
+            description: string;
+            type: string;
+            properties: {
+                timeout: {
+                    description: string;
+                    type: string;
+                    minimum: number;
+                };
+                maxKeys: {
+                    description: string;
+                    type: string;
+                    minimum: number;
+                };
+            };
+        };
+        filters: {
+            description: string;
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    type: {
+                        description: string;
                         type: string;
-                        minimum: number;
                     };
                 };
                 required: string[];
@@ -67,6 +191,11 @@ declare const CONFIGURATION_SCHEMA: {
                         type: string;
                         enum: string[];
                     };
+                    maxLevel: {
+                        description: string;
+                        type: string;
+                        enum: string[];
+                    };
                     target: {
                         oneOf: ({
                             type: string;
@@ -78,6 +207,10 @@ declare const CONFIGURATION_SCHEMA: {
                             };
                         })[];
                     };
+                    final: {
+                        description: string;
+                        type: string;
+                    };
                 };
                 required: string[];
             };

package/lib/cjs/schemas/log.configuration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log.configuration.d.ts","sourceRoot":"","sources":["../../../src/schemas/log.configuration.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiGzB,CAAC;AAEF,eAAe,oBAAoB,CAAC"}
+{"version":3,"file":"log.configuration.d.ts","sourceRoot":"","sources":["../../../src/schemas/log.configuration.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0PzB,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/lib/cjs/schemas/log.configuration.js

@@ -26,32 +26,147 @@ const CONFIGURATION_SCHEMA = {
                     enabled: {
                         type: "boolean",
                     },
-                    path: {
-                        type: "string",
-                    },
-                    archivePath: {
-                        type: "string",
-                    },
-                    maxSize: {
-                        type: "integer",
-                        minimum: 10000,
+                    filters: {
+                        description: "Per-target filter pipeline, applied only when writing to THIS target ( after the logger-level filters ). Each item is { type, ...opts } where `type` is the DI name of a LogFilter. Any returning null drops the entry for this target only.",
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                type: {
+                                    description: "DI string name of the registered LogFilter.",
+                                    type: "string",
+                                },
+                            },
+                            required: ["type"],
+                        },
                     },
-                    compress: {
-                        type: "boolean",
+                    // FileTarget options ( nested under `options` )
+                    options: {
+                        type: "object",
+                        properties: {
+                            path: {
+                                description: "Active log path, relative to the `fs` provider base path. Variables allowed.",
+                                type: "string",
+                            },
+                            archivePath: {
+                                description: "Archive directory, relative to the `archiveFs` provider base path. Variables allowed.",
+                                type: "string",
+                            },
+                            fs: {
+                                description: "Registered @spinajs/fs provider for the active log. Defaults to 'fs-log-default'.",
+                                type: "string",
+                            },
+                            archiveFs: {
+                                description: "Registered @spinajs/fs provider archives are moved to. Defaults to `fs`.",
+                                type: "string",
+                            },
+                            archiveStrategy: {
+                                description: "LogArchiveStrategy class name deciding WHEN to rotate. Default 'SizeLogArchiveStrategy'.",
+                                type: "string",
+                            },
+                            retentionStrategies: {
+                                description: "LogRetentionStrategy class names applied in order after rotation. Default ['CountLogRetentionStrategy'].",
+                                type: "array",
+                                items: {
+                                    type: "string",
+                                },
+                            },
+                            maxSize: {
+                                description: "Max active log size in bytes before rotation.",
+                                type: "integer",
+                                minimum: 1,
+                            },
+                            compress: {
+                                description: "Zip the archived file when moved to the archive.",
+                                type: "boolean",
+                            },
+                            rotate: {
+                                description: "Cron expression for CronLogArchiveStrategy ( 6-field with seconds ).",
+                                type: "string",
+                            },
+                            maxBufferSize: {
+                                description: "Max buffered messages before a flush.",
+                                type: "integer",
+                                minimum: 1,
+                            },
+                            maxQueueSize: {
+                                description: "Hard cap on buffered messages; oldest are dropped past this so a down sink cannot OOM.",
+                                type: "integer",
+                                minimum: 1,
+                            },
+                            maxArchiveFiles: {
+                                description: "How many archives to keep ( CountLogRetentionStrategy ). Oldest are deleted.",
+                                type: "integer",
+                                minimum: 1,
+                            },
+                            maxAge: {
+                                description: "Max archive age in seconds ( AgeLogRetentionStrategy ).",
+                                type: "integer",
+                                minimum: 1,
+                            },
+                            archiveInterval: {
+                                description: "Interval in seconds SizeLogArchiveStrategy checks the active log size.",
+                                type: "integer",
+                                minimum: 1,
+                            },
+                            flushInterval: {
+                                description: "Periodic flush tick in milliseconds for a partially filled buffer.",
+                                type: "integer",
+                                minimum: 1,
+                            },
+                        },
+                        required: ["path"],
                     },
-                    rotate: {
+                },
+                required: ["name", "type"],
+            },
+        },
+        file: {
+            description: "Default FileTarget options ( buffer / rotation / retention tunables ) merged UNDER every file target's own `options`. Shipped by @spinajs/log ( see logger.file defaults ) and overridable by user config.",
+            type: "object",
+        },
+        perf: {
+            description: "Performance-instrumentation ( Perf facade ) options for the default LogMetricSink.",
+            type: "object",
+            properties: {
+                enabled: { type: "boolean" },
+                thresholds: {
+                    description: "Per-metric-name slow threshold in ms. A name not present falls back to `default`; 0 means never slow.",
+                    type: "object",
+                },
+                overThresholdLevel: { type: "string", enum: ["trace", "debug", "info", "warn", "error"] },
+                underThresholdLevel: { type: "string", enum: ["trace", "debug", "info", "warn", "error"] },
+                logCounters: { type: "boolean" },
+            },
+        },
+        whenRepeated: {
+            description: "Opt-in dedup filter. Collapses identical repeated log entries within a timeout window into one, emitting a (xN) count when logging resumes. Off when absent; global for now.",
+            type: "object",
+            properties: {
+                timeout: {
+                    description: "Suppression window in SECONDS. Identical entries within this window are collapsed. Default 10.",
+                    type: "integer",
+                    minimum: 1,
+                },
+                maxKeys: {
+                    description: "Hard cap on tracked keys; the map self-prunes ( expired first, then oldest ) so memory stays bounded. Default 1024.",
+                    type: "integer",
+                    minimum: 1,
+                },
+            },
+        },
+        filters: {
+            description: "Composable per-logger filter pipeline. Each item is { type, ...opts } where `type` is the DI name of a LogFilter ( eg. LevelFilter, MatchFilter, RateLimitFilter, WhenRepeatedFilter ). Filters run in order in write(); any returning null drops the entry.",
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    type: {
+                        description: "DI string name of the registered LogFilter.",
                         type: "string",
                     },
-                    maxArchiveFiles: {
-                        type: "integer",
-                        minimum: 1,
-                    },
-                    bufferSize: {
-                        type: "integer",
-                        minimum: 1000,
-                    },
                 },
-                required: ["name", "type"],
+                required: ["type"],
             },
         },
         rules: {
@@ -78,6 +193,20 @@ const CONFIGURATION_SCHEMA = {
                             "success",
                         ],
                     },
+                    maxLevel: {
+                        description: "Optional INCLUSIVE upper bound of the level window this rule routes. With `level` as the lower bound, only entries in [level, maxLevel] are routed. Defaults to the highest level ( security ).",
+                        type: "string",
+                        enum: [
+                            "trace",
+                            "debug",
+                            "warn",
+                            "info",
+                            "error",
+                            "fatal",
+                            "security",
+                            "success",
+                        ],
+                    },
                     target: {
                         oneOf: [
                             {
@@ -91,6 +220,10 @@ const CONFIGURATION_SCHEMA = {
                             },
                         ],
                     },
+                    final: {
+                        description: "Stop evaluating further rules for a logger once this matching rule is applied ( NLog-style ). Earlier matched rules and this one still apply.",
+                        type: "boolean",
+                    },
                 },
                 required: ["name", "level", "target"],
             },

package/lib/cjs/schemas/log.configuration.js.map

@@ -1 +1 @@
-{"version":3,"file":"log.configuration.js","sourceRoot":"","sources":["../../../src/schemas/log.configuration.ts"],"names":[],"mappings":";;AAAA,MAAM,oBAAoB,GAAG;IAC3B,GAAG,EAAE,uCAAuC;IAC5C,oBAAoB,EAAE,QAAQ;IAC9B,WAAW,EAAE,wCAAwC;IACrD,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE;QACV,OAAO,EAAE;YACP,WAAW,EACT,wEAAwE;YAC1E,IAAI,EAAE,OAAO;YACb,QAAQ,EAAE,CAAC;YACX,WAAW,EAAE,IAAI;YACjB,KAAK,EAAE;gBACL,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,MAAM,EAAE;wBACN,IAAI,EAAE,QAAQ;qBACf;oBACD,IAAI,EAAE;wBACJ,IAAI,EAAE,QAAQ;qBACf;oBACD,IAAI,EAAE;wBACJ,IAAI,EAAE,QAAQ;qBACf;oBACD,OAAO,EAAE;wBACP,IAAI,EAAE,SAAS;qBAChB;oBACD,IAAI,EAAE;wBACJ,IAAI,EAAE,QAAQ;qBACf;oBACD,WAAW,EAAE;wBACX,IAAI,EAAE,QAAQ;qBACf;oBACD,OAAO,EAAE;wBACP,IAAI,EAAE,SAAS;wBACf,OAAO,EAAE,KAAK;qBACf;oBACD,QAAQ,EAAE;wBACR,IAAI,EAAE,SAAS;qBAChB;oBACD,MAAM,EAAE;wBACN,IAAI,EAAE,QAAQ;qBACf;oBACD,eAAe,EAAE;wBACf,IAAI,EAAE,SAAS;wBACf,OAAO,EAAE,CAAC;qBACX;oBACD,UAAU,EAAE;wBACV,IAAI,EAAE,SAAS;wBACf,OAAO,EAAE,IAAI;qBACd;iBACF;gBACD,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;aAC3B;SACF;QACD,KAAK,EAAE;YACL,WAAW,EAAE,2CAA2C;YACxD,IAAI,EAAE,OAAO;YACb,QAAQ,EAAE,CAAC;YACX,WAAW,EAAE,IAAI;YACjB,KAAK,EAAE;gBACL,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,IAAI,EAAE;wBACJ,IAAI,EAAE,QAAQ;qBACf;oBACD,KAAK,EAAE;wBACL,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE;4BACJ,OAAO;4BACP,OAAO;4BACP,MAAM;4BACN,MAAM;4BACN,OAAO;4BACP,OAAO;4BACP,UAAU;4BACV,SAAS;yBACV;qBACF;oBACD,MAAM,EAAE;wBACN,KAAK,EAAE;4BACL;gCACE,IAAI,EAAE,QAAQ;6BACf;4BACD;gCACE,IAAI,EAAE,OAAO;gCACb,KAAK,EAAE;oCACL,IAAI,EAAE,QAAQ;iCACf;6BACF;yBACF;qBACF;iBACF;gBACD,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC;aACtC;SACF;KACF;CACF,CAAC;AAEF,kBAAe,oBAAoB,CAAC"}
+{"version":3,"file":"log.configuration.js","sourceRoot":"","sources":["../../../src/schemas/log.configuration.ts"],"names":[],"mappings":"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"}

package/lib/cjs/targets/BrowserConsoleTarget.d.ts

@@ -0,0 +1,48 @@
+import { IColoredConsoleTargetOptions, ILogEntry, LogTarget } from "@spinajs/log-common";
+/**
+ * Browser counterpart of ColoredConsoleTarget: same "ConsoleTarget" DI name so
+ * existing logger configs resolve it unchanged, but no chalk (Node-only) — the
+ * browser devtools console provides its own styling per console method.
+ *
+ * Registered ONLY by the browser entry (index.browser.ts); never add it to
+ * targets/index.ts or it would fight ColoredConsoleTarget over "ConsoleTarget"
+ * on Node.
+ */
+export declare class BrowserConsoleTarget extends LogTarget<IColoredConsoleTargetOptions> {
+    protected StdConsoleCallbackMap: {
+        5: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        6: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        999: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        2: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        3: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        0: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        1: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        4: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+    };
+    write(data: ILogEntry): Promise<void>;
+}
+//# sourceMappingURL=BrowserConsoleTarget.d.ts.map

package/lib/cjs/targets/BrowserConsoleTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserConsoleTarget.d.ts","sourceRoot":"","sources":["../../../src/targets/BrowserConsoleTarget.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,SAAS,EAET,SAAS,EACV,MAAM,qBAAqB,CAAC;AAI7B;;;;;;;;GAQG;AACH,qBAEa,oBAAqB,SAAQ,SAAS,CAAC,4BAA4B,CAAC;IAC/E,SAAS,CAAC,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAY7B;IAEW,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CASnD"}

package/lib/cjs/targets/BrowserConsoleTarget.js

@@ -0,0 +1,48 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserConsoleTarget = void 0;
+const log_common_1 = require("@spinajs/log-common");
+const di_1 = require("@spinajs/di");
+const configuration_common_1 = require("@spinajs/configuration-common");
+/**
+ * Browser counterpart of ColoredConsoleTarget: same "ConsoleTarget" DI name so
+ * existing logger configs resolve it unchanged, but no chalk (Node-only) — the
+ * browser devtools console provides its own styling per console method.
+ *
+ * Registered ONLY by the browser entry (index.browser.ts); never add it to
+ * targets/index.ts or it would fight ColoredConsoleTarget over "ConsoleTarget"
+ * on Node.
+ */
+let BrowserConsoleTarget = class BrowserConsoleTarget extends log_common_1.LogTarget {
+    constructor() {
+        super(...arguments);
+        this.StdConsoleCallbackMap = {
+            [log_common_1.LogLevel.Error]: console.error,
+            [log_common_1.LogLevel.Fatal]: console.error,
+            [log_common_1.LogLevel.Security]: console.error,
+            [log_common_1.LogLevel.Info]: console.log,
+            [log_common_1.LogLevel.Success]: console.log,
+            [log_common_1.LogLevel.Trace]: console.debug,
+            [log_common_1.LogLevel.Debug]: console.debug,
+            [log_common_1.LogLevel.Warn]: console.warn,
+        };
+    }
+    async write(data) {
+        if (!this.Options.enabled) {
+            return;
+        }
+        this.StdConsoleCallbackMap[data.Level]((0, configuration_common_1.format)(data.Variables, this.Options.layout));
+    }
+};
+exports.BrowserConsoleTarget = BrowserConsoleTarget;
+exports.BrowserConsoleTarget = BrowserConsoleTarget = __decorate([
+    (0, di_1.Singleton)(),
+    (0, di_1.Injectable)("ConsoleTarget")
+], BrowserConsoleTarget);
+//# sourceMappingURL=BrowserConsoleTarget.js.map

package/lib/cjs/targets/BrowserConsoleTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserConsoleTarget.js","sourceRoot":"","sources":["../../../src/targets/BrowserConsoleTarget.ts"],"names":[],"mappings":";;;;;;;;;AAAA,oDAK6B;AAC7B,oCAAoD;AACpD,wEAAuD;AAEvD;;;;;;;;GAQG;AAGI,IAAM,oBAAoB,GAA1B,MAAM,oBAAqB,SAAQ,sBAAuC;IAA1E;;QACK,0BAAqB,GAAG;YAChC,CAAC,qBAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK;YAC/B,CAAC,qBAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK;YAC/B,CAAC,qBAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,KAAK;YAElC,CAAC,qBAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,GAAG;YAC5B,CAAC,qBAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GAAG;YAE/B,CAAC,qBAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK;YAC/B,CAAC,qBAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK;YAE/B,CAAC,qBAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI;SAC9B,CAAC;IAWJ,CAAC;IATQ,KAAK,CAAC,KAAK,CAAC,IAAe;QAChC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CACpC,IAAA,6BAAM,EAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAC5C,CAAC;IACJ,CAAC;CACF,CAAA;AAxBY,oDAAoB;+BAApB,oBAAoB;IAFhC,IAAA,cAAS,GAAE;IACX,IAAA,eAAU,EAAC,eAAe,CAAC;GACf,oBAAoB,CAwBhC"}

package/lib/cjs/targets/ColoredConsoleTarget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ColoredConsoleTarget.d.ts","sourceRoot":"","sources":["../../../src/targets/ColoredConsoleTarget.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,SAAS,EACT,SAAS,EACV,MAAM,qBAAqB,CAAC;AAM7B,eAAO,MAAM,aAAa;;;;;;;;;CASzB,CAAC;AAEF,qBAEa,oBAAqB,SAAQ,SAAS,CAAC,4BAA4B,CAAC;IAC/E,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,CAAM;IAE5B,SAAS,CAAC,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAY7B;IAEW,OAAO;IAaP,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CAenD"}
+{"version":3,"file":"ColoredConsoleTarget.d.ts","sourceRoot":"","sources":["../../../src/targets/ColoredConsoleTarget.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,SAAS,EACT,SAAS,EACV,MAAM,qBAAqB,CAAC;AAmB7B,eAAO,MAAM,aAAa;;;;;;;;;CASzB,CAAC;AAEF,qBAEa,oBAAqB,SAAQ,SAAS,CAAC,4BAA4B,CAAC;IAC/E,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,CAAM;IAE5B,SAAS,CAAC,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAY7B;IAEW,OAAO;IAaP,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CAenD"}

package/lib/cjs/targets/ColoredConsoleTarget.js

@@ -5,16 +5,25 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ColoredConsoleTarget = exports.DEFAULT_THEME = void 0;
 const log_common_1 = require("@spinajs/log-common");
 const di_1 = require("@spinajs/di");
 const index_js_1 = require("./../index.js");
-const chalk_1 = __importDefault(require("chalk"));
 const configuration_1 = require("@spinajs/configuration");
+/**
+ * Minimal, dependency-free ANSI colour helpers ( replaces chalk ).
+ * Console target is Node-only, so raw escape codes are fine.
+ */
+const ANSI_RESET = "\x1b[0m";
+const ansi = (open) => (text) => `${open}${text}${ANSI_RESET}`;
+const gray = ansi("\x1b[90m");
+const white = ansi("\x1b[37m");
+const whiteBgGreen = ansi("\x1b[37m\x1b[42m");
+const yellow = ansi("\x1b[33m");
+const red = ansi("\x1b[31m");
+const whiteBgRed = ansi("\x1b[37m\x1b[41m");
+const yellowBgRed = ansi("\x1b[33m\x1b[41m");
 exports.DEFAULT_THEME = {
     security: ["red", "bgBrightWhite"],
     fatal: "red",
@@ -41,14 +50,14 @@ let ColoredConsoleTarget = class ColoredConsoleTarget extends log_common_1.LogTa
         };
     }
     async resolve() {
-        this.theme[index_js_1.LogLevel.Trace] = chalk_1.default.gray;
-        this.theme[index_js_1.LogLevel.Debug] = chalk_1.default.gray;
-        this.theme[index_js_1.LogLevel.Info] = chalk_1.default.white;
-        this.theme[index_js_1.LogLevel.Success] = chalk_1.default.white.bgGreen;
-        this.theme[index_js_1.LogLevel.Warn] = chalk_1.default.yellow;
-        this.theme[index_js_1.LogLevel.Error] = chalk_1.default.red;
-        this.theme[index_js_1.LogLevel.Fatal] = chalk_1.default.white.bgRed;
-        this.theme[index_js_1.LogLevel.Security] = chalk_1.default.yellow.bgRed;
+        this.theme[index_js_1.LogLevel.Trace] = gray;
+        this.theme[index_js_1.LogLevel.Debug] = gray;
+        this.theme[index_js_1.LogLevel.Info] = white;
+        this.theme[index_js_1.LogLevel.Success] = whiteBgGreen;
+        this.theme[index_js_1.LogLevel.Warn] = yellow;
+        this.theme[index_js_1.LogLevel.Error] = red;
+        this.theme[index_js_1.LogLevel.Fatal] = whiteBgRed;
+        this.theme[index_js_1.LogLevel.Security] = yellowBgRed;
         super.resolve();
     }
     async write(data) {