logixia 1.12.6 → 1.13.3

package/README.md

@@ -1291,6 +1291,15 @@ The filter returns a consistent structured shape on every error:
 }
 ```
 
+The `debug` block (stack trace, service, duration) is **off by default** and is never sent to clients unless you opt in, for example in local development only:
+
+```typescript
+new LogixiaExceptionFilter(undefined, undefined, {
+  exposeDebug: process.env.NODE_ENV === 'development',
+  // exposeCause: true,  // also include the underlying error message (may contain internal detail)
+});
+```
+
 And every log line carries `method`, `url`, `status`, `request_id` as structured fields — not a plain string:
 
 ```
@@ -1316,22 +1325,28 @@ logixia ships this as a dedicated `logixia/correlation` sub-package. It uses the
 ```typescript
 import { correlationMiddleware } from 'logixia/correlation';
 
-// Zero-config — reads X-Correlation-ID / X-Request-ID from the incoming request.
-// Generates a UUID v4 if no header is present.
+// Zero-config — reads X-Correlation-ID from the incoming request.
+// Generates a UUID v4 if the header is missing or invalid.
 // Sets X-Correlation-ID on the response.
 app.use(correlationMiddleware());
 
 // Custom config:
 app.use(
   correlationMiddleware({
-    header: 'X-Correlation-ID', // header to read / write. Default: 'X-Correlation-ID'
-    generateId: () => crypto.randomUUID(),
+    header: 'X-Correlation-ID', // header to read / write (matched case-insensitively). Default: 'x-correlation-id'
+    generate: () => crypto.randomUUID(), // used when no usable incoming ID. Default: crypto.randomUUID()
     trustIncoming: true, // honour the header from the client. Default: true
     setResponseHeader: true, // echo the ID back in the response. Default: true
   })
 );
 ```
 
+An incoming ID is only used if it is at most 128 characters long and contains only
+`A-Z`, `a-z`, `0-9`, `.`, `_`, `:` and `-`. Anything else (newlines, spaces, or base64-style
+`+`, `/`, `=`) is replaced with a freshly generated ID, so client-supplied text can't end up in
+every log line. Set `trustIncoming: false` to ignore the incoming header entirely and always
+generate a new ID. `correlationFastifyHook()` takes the same options.
+
 ### Correlation Fastify hook
 
 ```typescript

package/dist/{async-context-CwBNMm2E.mjs → async-context-BzJrbfQs.mjs}

@@ -1,3 +1,4 @@
+import { d as sanitizeIncomingId } from "./trace.utils-CvXgaiQT.mjs";
 import { randomUUID } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 
@@ -21,7 +22,10 @@ const LogixiaContext = {
 	set(fields) {
 		const store = _storage.getStore();
 		if (!store) return;
-		Object.assign(store, fields);
+		for (const key of Object.keys(fields)) {
+			if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+			store[key] = fields[key];
+		}
 	},
 	getStorage() {
 		return _storage;
@@ -40,7 +44,7 @@ const LogixiaContext = {
 function createExpressContextMiddleware(options = {}) {
 	const { enrich, traceIdHeader = "x-trace-id" } = options;
 	return function logixiaContextMiddleware(req, _res, next) {
-		const base = { traceId: (req["headers"] ?? {})[traceIdHeader] ?? randomShortId() };
+		const base = { traceId: sanitizeIncomingId((req["headers"] ?? {})[traceIdHeader.toLowerCase()]) ?? randomShortId() };
 		LogixiaContext.run({
 			...base,
 			...enrich ? enrich(req) : {}
@@ -55,7 +59,7 @@ function createExpressContextMiddleware(options = {}) {
 function createFastifyContextHook(options = {}) {
 	const { enrich, traceIdHeader = "x-trace-id" } = options;
 	return function logixiaFastifyHook(request, _reply, done) {
-		const base = { traceId: (request["headers"] ?? {})[traceIdHeader] ?? request["id"] ?? randomShortId() };
+		const base = { traceId: sanitizeIncomingId((request["headers"] ?? {})[traceIdHeader.toLowerCase()]) ?? sanitizeIncomingId(request["id"]) ?? randomShortId() };
 		LogixiaContext.run({
 			...base,
 			...enrich ? enrich(request) : {}
@@ -65,4 +69,4 @@ function createFastifyContextHook(options = {}) {
 
 //#endregion
 export { createExpressContextMiddleware as n, createFastifyContextHook as r, LogixiaContext as t };
-//# sourceMappingURL=async-context-CwBNMm2E.mjs.map
+//# sourceMappingURL=async-context-BzJrbfQs.mjs.map

package/dist/async-context-BzJrbfQs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-context-BzJrbfQs.mjs","names":["base: LogContext"],"sources":["../src/context/async-context.ts"],"sourcesContent":["/**\n * LogixiaContext — Zero-boilerplate AsyncLocalStorage context propagation.\n *\n * Lets every `logger.info()` call inside a context automatically pick up stored\n * fields (requestId, userId, tenantId, …) without passing them through every function.\n *\n * Works across `Promise.all`, `setTimeout`, and event emitters — anything that\n * inherits the async execution context.\n *\n * @example\n * ```ts\n * import { LogixiaContext } from 'logixia';\n *\n * // Wrap a request handler:\n * app.use((req, res, next) => {\n *   LogixiaContext.run({ requestId: req.id, userId: req.user?.id }, next);\n * });\n *\n * // Anywhere deeper in the call tree:\n * async function processOrder(orderId: string) {\n *   const ctx = LogixiaContext.get();  // { requestId, userId, orderId }\n *   logger.info('Processing order', { orderId, ...ctx });\n * }\n * ```\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\nimport { randomUUID } from 'node:crypto';\n\nimport { sanitizeIncomingId } from '../utils/trace.utils';\n\n/** Generates an 8-character random ID using Node's crypto module. */\nfunction randomShortId(): string {\n  return randomUUID().slice(0, 8);\n}\n\nexport interface LogContext {\n  traceId?: string;\n  spanId?: string;\n  userId?: string;\n  tenantId?: string;\n  sessionId?: string;\n  [key: string]: unknown;\n}\n\n// Module-level singleton so all loggers share the same ALS store.\nconst _storage = new AsyncLocalStorage<LogContext>();\n\nexport const LogixiaContext = {\n  /**\n   * Run `callback` inside an async context that carries `store` fields.\n   * All loggers queried within `callback` (and its async descendants) will\n   * automatically see these fields.\n   *\n   * @example\n   * ```ts\n   * LogixiaContext.run({ requestId: 'abc', userId: '42' }, async () => {\n   *   await processOrder();   // sees requestId + userId in every log\n   * });\n   * ```\n   */\n  run<T>(store: LogContext, callback: () => T): T {\n    const parent = _storage.getStore() ?? {};\n    return _storage.run({ ...parent, ...store }, callback);\n  },\n\n  /**\n   * Return the context fields active in the current async scope.\n   * Returns `undefined` when called outside any `LogixiaContext.run()`.\n   */\n  get(): LogContext | undefined {\n    return _storage.getStore();\n  },\n\n  /**\n   * Merge `fields` into the **existing** context for the current scope.\n   * If called outside a `run()` context this is a no-op (logs a dev warning).\n   */\n  set(fields: Partial<LogContext>): void {\n    const store = _storage.getStore();\n    if (!store) {\n      // Silently ignore — avoids crashing in code that may call setContext\n      // before a request context is established (e.g. background jobs).\n      return;\n    }\n    for (const key of Object.keys(fields)) {\n      if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue;\n      store[key] = fields[key];\n    }\n  },\n\n  /**\n   * Retrieve the underlying `AsyncLocalStorage` instance.\n   * Useful for advanced use-cases like custom middleware.\n   */\n  getStorage(): AsyncLocalStorage<LogContext> {\n    return _storage;\n  },\n};\n\n/**\n * Create an Express/Connect-compatible middleware that wraps each request in\n * a `LogixiaContext.run()` scope populated with common request fields.\n *\n * @example\n * ```ts\n * import { createExpressContextMiddleware } from 'logixia';\n * app.use(createExpressContextMiddleware());\n * ```\n */\nexport function createExpressContextMiddleware(\n  options: {\n    /** Extract additional fields from the request. */\n    enrich?: (req: Record<string, unknown>) => Partial<LogContext>;\n    /** Header to read the traceId from. Default: 'x-trace-id'. */\n    traceIdHeader?: string;\n  } = {}\n) {\n  const { enrich, traceIdHeader = 'x-trace-id' } = options;\n\n  return function logixiaContextMiddleware(\n    req: Record<string, unknown>,\n    _res: unknown,\n    next: () => void\n  ): void {\n    const headers = (req['headers'] ?? {}) as Record<string, string | undefined>;\n    const traceId = sanitizeIncomingId(headers[traceIdHeader.toLowerCase()]) ?? randomShortId();\n    const base: LogContext = { traceId };\n    LogixiaContext.run({ ...base, ...(enrich ? enrich(req) : {}) }, next);\n  };\n}\n\n/**\n * Create a Fastify lifecycle hook that wraps each request in a context scope.\n *\n * Register with `fastify.addHook('onRequest', createFastifyContextHook())`.\n */\nexport function createFastifyContextHook(\n  options: {\n    enrich?: (request: Record<string, unknown>) => Partial<LogContext>;\n    traceIdHeader?: string;\n  } = {}\n) {\n  const { enrich, traceIdHeader = 'x-trace-id' } = options;\n\n  return function logixiaFastifyHook(\n    request: Record<string, unknown>,\n    _reply: unknown,\n    done: () => void\n  ): void {\n    const headers = (request['headers'] ?? {}) as Record<string, string | undefined>;\n    const traceId =\n      sanitizeIncomingId(headers[traceIdHeader.toLowerCase()]) ??\n      sanitizeIncomingId(request['id']) ??\n      randomShortId();\n    const base: LogContext = { traceId };\n    LogixiaContext.run({ ...base, ...(enrich ? enrich(request) : {}) }, done);\n  };\n}\n"],"mappings":";;;;;;AAgCA,SAAS,gBAAwB;AAC/B,QAAO,YAAY,CAAC,MAAM,GAAG,EAAE;;AAajC,MAAM,WAAW,IAAI,mBAA+B;AAEpD,MAAa,iBAAiB;CAa5B,IAAO,OAAmB,UAAsB;EAC9C,MAAM,SAAS,SAAS,UAAU,IAAI,EAAE;AACxC,SAAO,SAAS,IAAI;GAAE,GAAG;GAAQ,GAAG;GAAO,EAAE,SAAS;;CAOxD,MAA8B;AAC5B,SAAO,SAAS,UAAU;;CAO5B,IAAI,QAAmC;EACrC,MAAM,QAAQ,SAAS,UAAU;AACjC,MAAI,CAAC,MAGH;AAEF,OAAK,MAAM,OAAO,OAAO,KAAK,OAAO,EAAE;AACrC,OAAI,QAAQ,eAAe,QAAQ,iBAAiB,QAAQ,YAAa;AACzE,SAAM,OAAO,OAAO;;;CAQxB,aAA4C;AAC1C,SAAO;;CAEV;;;;;;;;;;;AAYD,SAAgB,+BACd,UAKI,EAAE,EACN;CACA,MAAM,EAAE,QAAQ,gBAAgB,iBAAiB;AAEjD,QAAO,SAAS,yBACd,KACA,MACA,MACM;EAGN,MAAMA,OAAmB,EAAE,SADX,oBADC,IAAI,cAAc,EAAE,EACM,cAAc,aAAa,EAAE,IAAI,eAAe,EACvD;AACpC,iBAAe,IAAI;GAAE,GAAG;GAAM,GAAI,SAAS,OAAO,IAAI,GAAG,EAAE;GAAG,EAAE,KAAK;;;;;;;;AASzE,SAAgB,yBACd,UAGI,EAAE,EACN;CACA,MAAM,EAAE,QAAQ,gBAAgB,iBAAiB;AAEjD,QAAO,SAAS,mBACd,SACA,QACA,MACM;EAMN,MAAMA,OAAmB,EAAE,SAHzB,oBAFe,QAAQ,cAAc,EAAE,EAEZ,cAAc,aAAa,EAAE,IACxD,mBAAmB,QAAQ,MAAM,IACjC,eAAe,EACmB;AACpC,iBAAe,IAAI;GAAE,GAAG;GAAM,GAAI,SAAS,OAAO,QAAQ,GAAG,EAAE;GAAG,EAAE,KAAK"}

package/dist/{async-context-CSHWoHMB.js → async-context-DyQQYq3I.js}

@@ -1,4 +1,5 @@
 const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_trace_utils = require('./trace.utils-DpBOLDtq.js');
 let node_crypto = require("node:crypto");
 node_crypto = require_chunk.__toESM(node_crypto);
 let node_async_hooks = require("node:async_hooks");
@@ -24,7 +25,10 @@ const LogixiaContext = {
 	set(fields) {
 		const store = _storage.getStore();
 		if (!store) return;
-		Object.assign(store, fields);
+		for (const key of Object.keys(fields)) {
+			if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+			store[key] = fields[key];
+		}
 	},
 	getStorage() {
 		return _storage;
@@ -43,7 +47,7 @@ const LogixiaContext = {
 function createExpressContextMiddleware(options = {}) {
 	const { enrich, traceIdHeader = "x-trace-id" } = options;
 	return function logixiaContextMiddleware(req, _res, next) {
-		const base = { traceId: (req["headers"] ?? {})[traceIdHeader] ?? randomShortId() };
+		const base = { traceId: require_trace_utils.sanitizeIncomingId((req["headers"] ?? {})[traceIdHeader.toLowerCase()]) ?? randomShortId() };
 		LogixiaContext.run({
 			...base,
 			...enrich ? enrich(req) : {}
@@ -58,7 +62,7 @@ function createExpressContextMiddleware(options = {}) {
 function createFastifyContextHook(options = {}) {
 	const { enrich, traceIdHeader = "x-trace-id" } = options;
 	return function logixiaFastifyHook(request, _reply, done) {
-		const base = { traceId: (request["headers"] ?? {})[traceIdHeader] ?? request["id"] ?? randomShortId() };
+		const base = { traceId: require_trace_utils.sanitizeIncomingId((request["headers"] ?? {})[traceIdHeader.toLowerCase()]) ?? require_trace_utils.sanitizeIncomingId(request["id"]) ?? randomShortId() };
 		LogixiaContext.run({
 			...base,
 			...enrich ? enrich(request) : {}
@@ -85,4 +89,4 @@ Object.defineProperty(exports, 'createFastifyContextHook', {
     return createFastifyContextHook;
   }
 });
-//# sourceMappingURL=async-context-CSHWoHMB.js.map
+//# sourceMappingURL=async-context-DyQQYq3I.js.map

package/dist/async-context-DyQQYq3I.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-context-DyQQYq3I.js","names":["AsyncLocalStorage","base: LogContext","sanitizeIncomingId"],"sources":["../src/context/async-context.ts"],"sourcesContent":["/**\n * LogixiaContext — Zero-boilerplate AsyncLocalStorage context propagation.\n *\n * Lets every `logger.info()` call inside a context automatically pick up stored\n * fields (requestId, userId, tenantId, …) without passing them through every function.\n *\n * Works across `Promise.all`, `setTimeout`, and event emitters — anything that\n * inherits the async execution context.\n *\n * @example\n * ```ts\n * import { LogixiaContext } from 'logixia';\n *\n * // Wrap a request handler:\n * app.use((req, res, next) => {\n *   LogixiaContext.run({ requestId: req.id, userId: req.user?.id }, next);\n * });\n *\n * // Anywhere deeper in the call tree:\n * async function processOrder(orderId: string) {\n *   const ctx = LogixiaContext.get();  // { requestId, userId, orderId }\n *   logger.info('Processing order', { orderId, ...ctx });\n * }\n * ```\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\nimport { randomUUID } from 'node:crypto';\n\nimport { sanitizeIncomingId } from '../utils/trace.utils';\n\n/** Generates an 8-character random ID using Node's crypto module. */\nfunction randomShortId(): string {\n  return randomUUID().slice(0, 8);\n}\n\nexport interface LogContext {\n  traceId?: string;\n  spanId?: string;\n  userId?: string;\n  tenantId?: string;\n  sessionId?: string;\n  [key: string]: unknown;\n}\n\n// Module-level singleton so all loggers share the same ALS store.\nconst _storage = new AsyncLocalStorage<LogContext>();\n\nexport const LogixiaContext = {\n  /**\n   * Run `callback` inside an async context that carries `store` fields.\n   * All loggers queried within `callback` (and its async descendants) will\n   * automatically see these fields.\n   *\n   * @example\n   * ```ts\n   * LogixiaContext.run({ requestId: 'abc', userId: '42' }, async () => {\n   *   await processOrder();   // sees requestId + userId in every log\n   * });\n   * ```\n   */\n  run<T>(store: LogContext, callback: () => T): T {\n    const parent = _storage.getStore() ?? {};\n    return _storage.run({ ...parent, ...store }, callback);\n  },\n\n  /**\n   * Return the context fields active in the current async scope.\n   * Returns `undefined` when called outside any `LogixiaContext.run()`.\n   */\n  get(): LogContext | undefined {\n    return _storage.getStore();\n  },\n\n  /**\n   * Merge `fields` into the **existing** context for the current scope.\n   * If called outside a `run()` context this is a no-op (logs a dev warning).\n   */\n  set(fields: Partial<LogContext>): void {\n    const store = _storage.getStore();\n    if (!store) {\n      // Silently ignore — avoids crashing in code that may call setContext\n      // before a request context is established (e.g. background jobs).\n      return;\n    }\n    for (const key of Object.keys(fields)) {\n      if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue;\n      store[key] = fields[key];\n    }\n  },\n\n  /**\n   * Retrieve the underlying `AsyncLocalStorage` instance.\n   * Useful for advanced use-cases like custom middleware.\n   */\n  getStorage(): AsyncLocalStorage<LogContext> {\n    return _storage;\n  },\n};\n\n/**\n * Create an Express/Connect-compatible middleware that wraps each request in\n * a `LogixiaContext.run()` scope populated with common request fields.\n *\n * @example\n * ```ts\n * import { createExpressContextMiddleware } from 'logixia';\n * app.use(createExpressContextMiddleware());\n * ```\n */\nexport function createExpressContextMiddleware(\n  options: {\n    /** Extract additional fields from the request. */\n    enrich?: (req: Record<string, unknown>) => Partial<LogContext>;\n    /** Header to read the traceId from. Default: 'x-trace-id'. */\n    traceIdHeader?: string;\n  } = {}\n) {\n  const { enrich, traceIdHeader = 'x-trace-id' } = options;\n\n  return function logixiaContextMiddleware(\n    req: Record<string, unknown>,\n    _res: unknown,\n    next: () => void\n  ): void {\n    const headers = (req['headers'] ?? {}) as Record<string, string | undefined>;\n    const traceId = sanitizeIncomingId(headers[traceIdHeader.toLowerCase()]) ?? randomShortId();\n    const base: LogContext = { traceId };\n    LogixiaContext.run({ ...base, ...(enrich ? enrich(req) : {}) }, next);\n  };\n}\n\n/**\n * Create a Fastify lifecycle hook that wraps each request in a context scope.\n *\n * Register with `fastify.addHook('onRequest', createFastifyContextHook())`.\n */\nexport function createFastifyContextHook(\n  options: {\n    enrich?: (request: Record<string, unknown>) => Partial<LogContext>;\n    traceIdHeader?: string;\n  } = {}\n) {\n  const { enrich, traceIdHeader = 'x-trace-id' } = options;\n\n  return function logixiaFastifyHook(\n    request: Record<string, unknown>,\n    _reply: unknown,\n    done: () => void\n  ): void {\n    const headers = (request['headers'] ?? {}) as Record<string, string | undefined>;\n    const traceId =\n      sanitizeIncomingId(headers[traceIdHeader.toLowerCase()]) ??\n      sanitizeIncomingId(request['id']) ??\n      randomShortId();\n    const base: LogContext = { traceId };\n    LogixiaContext.run({ ...base, ...(enrich ? enrich(request) : {}) }, done);\n  };\n}\n"],"mappings":";;;;;;;;;AAgCA,SAAS,gBAAwB;AAC/B,qCAAmB,CAAC,MAAM,GAAG,EAAE;;AAajC,MAAM,WAAW,IAAIA,oCAA+B;AAEpD,MAAa,iBAAiB;CAa5B,IAAO,OAAmB,UAAsB;EAC9C,MAAM,SAAS,SAAS,UAAU,IAAI,EAAE;AACxC,SAAO,SAAS,IAAI;GAAE,GAAG;GAAQ,GAAG;GAAO,EAAE,SAAS;;CAOxD,MAA8B;AAC5B,SAAO,SAAS,UAAU;;CAO5B,IAAI,QAAmC;EACrC,MAAM,QAAQ,SAAS,UAAU;AACjC,MAAI,CAAC,MAGH;AAEF,OAAK,MAAM,OAAO,OAAO,KAAK,OAAO,EAAE;AACrC,OAAI,QAAQ,eAAe,QAAQ,iBAAiB,QAAQ,YAAa;AACzE,SAAM,OAAO,OAAO;;;CAQxB,aAA4C;AAC1C,SAAO;;CAEV;;;;;;;;;;;AAYD,SAAgB,+BACd,UAKI,EAAE,EACN;CACA,MAAM,EAAE,QAAQ,gBAAgB,iBAAiB;AAEjD,QAAO,SAAS,yBACd,KACA,MACA,MACM;EAGN,MAAMC,OAAmB,EAAE,SADXC,wCADC,IAAI,cAAc,EAAE,EACM,cAAc,aAAa,EAAE,IAAI,eAAe,EACvD;AACpC,iBAAe,IAAI;GAAE,GAAG;GAAM,GAAI,SAAS,OAAO,IAAI,GAAG,EAAE;GAAG,EAAE,KAAK;;;;;;;;AASzE,SAAgB,yBACd,UAGI,EAAE,EACN;CACA,MAAM,EAAE,QAAQ,gBAAgB,iBAAiB;AAEjD,QAAO,SAAS,mBACd,SACA,QACA,MACM;EAMN,MAAMD,OAAmB,EAAE,SAHzBC,wCAFe,QAAQ,cAAc,EAAE,EAEZ,cAAc,aAAa,EAAE,IACxDA,uCAAmB,QAAQ,MAAM,IACjC,eAAe,EACmB;AACpC,iBAAe,IAAI;GAAE,GAAG;GAAM,GAAI,SAAS,OAAO,QAAQ,GAAG,EAAE;GAAG,EAAE,KAAK"}

package/dist/{azure-monitor.transport-CG7ClkYj.d.ts → azure-monitor.transport-BDFO4F-i.d.ts}

@@ -1,4 +1,4 @@
-import { p as TransportLogEntry, s as IAsyncTransport } from "./transport.types-BuY84TwO.js";
+import { p as TransportLogEntry, s as IAsyncTransport } from "./transport.types-DqVLZTyf.js";
 
 //#region src/transports/azure-monitor.transport.d.ts
 
@@ -59,4 +59,4 @@ declare class AzureMonitorTransport implements IAsyncTransport {
 }
 //#endregion
 export { AzureMonitorTransportConfig as n, AzureMonitorTransport as t };
-//# sourceMappingURL=azure-monitor.transport-CG7ClkYj.d.ts.map
+//# sourceMappingURL=azure-monitor.transport-BDFO4F-i.d.ts.map

package/dist/{azure-monitor.transport-CG7ClkYj.d.ts.map → azure-monitor.transport-BDFO4F-i.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"azure-monitor.transport-CG7ClkYj.d.ts","names":[],"sources":["../src/transports/azure-monitor.transport.ts"],"sourcesContent":[],"mappings":";;;;UAkDiB,2BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCJ,qBAAA,YAAiC;;;;;;;;;;;;;;;;sBAmBxB;eAwBP;WAKJ;;;;;;WASM"}
+{"version":3,"file":"azure-monitor.transport-BDFO4F-i.d.ts","names":[],"sources":["../src/transports/azure-monitor.transport.ts"],"sourcesContent":[],"mappings":";;;;UAkDiB,2BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCJ,qBAAA,YAAiC;;;;;;;;;;;;;;;;sBAmBxB;eAwBP;WAKJ;;;;;;WASM"}

package/dist/{azure-monitor.transport-Cm74kXZS.d.mts → azure-monitor.transport-D5wQEH04.d.mts}

@@ -1,4 +1,4 @@
-import { p as TransportLogEntry, s as IAsyncTransport } from "./transport.types-B5vcyv2k.mjs";
+import { p as TransportLogEntry, s as IAsyncTransport } from "./transport.types-CtNr3D7S.mjs";
 
 //#region src/transports/azure-monitor.transport.d.ts
 
@@ -59,4 +59,4 @@ declare class AzureMonitorTransport implements IAsyncTransport {
 }
 //#endregion
 export { AzureMonitorTransportConfig as n, AzureMonitorTransport as t };
-//# sourceMappingURL=azure-monitor.transport-Cm74kXZS.d.mts.map
+//# sourceMappingURL=azure-monitor.transport-D5wQEH04.d.mts.map

package/dist/{azure-monitor.transport-Cm74kXZS.d.mts.map → azure-monitor.transport-D5wQEH04.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"azure-monitor.transport-Cm74kXZS.d.mts","names":[],"sources":["../src/transports/azure-monitor.transport.ts"],"sourcesContent":[],"mappings":";;;;UAkDiB,2BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCJ,qBAAA,YAAiC;;;;;;;;;;;;;;;;sBAmBxB;eAwBP;WAKJ;;;;;;WASM"}
+{"version":3,"file":"azure-monitor.transport-D5wQEH04.d.mts","names":[],"sources":["../src/transports/azure-monitor.transport.ts"],"sourcesContent":[],"mappings":";;;;UAkDiB,2BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCJ,qBAAA,YAAiC;;;;;;;;;;;;;;;;sBAmBxB;eAwBP;WAKJ;;;;;;WASM"}

package/dist/azure.d.mts

@@ -1,3 +1,3 @@
-import "./transport.types-B5vcyv2k.mjs";
-import { n as AzureMonitorTransportConfig, t as AzureMonitorTransport } from "./azure-monitor.transport-Cm74kXZS.mjs";
+import "./transport.types-CtNr3D7S.mjs";
+import { n as AzureMonitorTransportConfig, t as AzureMonitorTransport } from "./azure-monitor.transport-D5wQEH04.mjs";
 export { AzureMonitorTransport, AzureMonitorTransportConfig };

package/dist/azure.d.ts

@@ -1,3 +1,3 @@
-import "./transport.types-BuY84TwO.js";
-import { n as AzureMonitorTransportConfig, t as AzureMonitorTransport } from "./azure-monitor.transport-CG7ClkYj.js";
+import "./transport.types-DqVLZTyf.js";
+import { n as AzureMonitorTransportConfig, t as AzureMonitorTransport } from "./azure-monitor.transport-BDFO4F-i.js";
 export { AzureMonitorTransport, AzureMonitorTransportConfig };

package/dist/cli/index.js

@@ -31,6 +31,25 @@ commander = __toESM(commander);
 let picocolors = require("picocolors");
 picocolors = __toESM(picocolors);
 
+//#region src/utils/csv.utils.ts
+const CSV_FORMULA_PREFIX = /^[=+\-@\t\r]/;
+/**
+* Render one CSV field. String values that a spreadsheet would treat as a
+* formula (leading `=`, `+`, `-`, `@`, tab or CR) are prefixed with `'`.
+* Objects are JSON-encoded. Fields containing a comma, quote, CR or LF are quoted;
+* `alwaysQuote` quotes every field. `null` / `undefined` render as empty.
+*/
+function csvField(value, alwaysQuote = false) {
+	if (value === void 0 || value === null) return alwaysQuote ? "\"\"" : "";
+	let str;
+	if (typeof value === "string") str = CSV_FORMULA_PREFIX.test(value) ? `'${value}` : value;
+	else if (typeof value === "object") str = JSON.stringify(value);
+	else str = String(value);
+	if (alwaysQuote || /[",\r\n]/.test(str)) return `"${str.replace(/"/g, "\"\"")}"`;
+	return str;
+}
+
+//#endregion
 //#region src/cli/utils.ts
 /**
 * Render a single cell value. Uses a null/undefined check rather than `||` so
@@ -38,12 +57,33 @@ picocolors = __toESM(picocolors);
 * `statusCode=0` field must not silently display as blank.
 */
 function cellText(value) {
-	return value === null || value === void 0 ? "" : String(value);
+	return value === null || value === void 0 ? "" : sanitizeInline(String(value));
+}
+const TERMINAL_UNSAFE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u2028\u2029]/g;
+function escapeChar(ch) {
+	const code = ch.charCodeAt(0);
+	return code <= 255 ? `\\x${code.toString(16).padStart(2, "0")}` : `\\u${code.toString(16).padStart(4, "0")}`;
+}
+/**
+* Make untrusted log text safe to print: control characters (ESC, CR, BEL, C1
+* codes, ...) are replaced by a visible `\xNN` escape. Tabs and newlines are kept
+* so multi-line output the CLI formats itself is unaffected.
+*/
+function sanitizeForTerminal(text) {
+	return text.replace(TERMINAL_UNSAFE, escapeChar);
+}
+/** Like {@link sanitizeForTerminal} but also escapes newlines and tabs (single-line cells). */
+function sanitizeInline(text) {
+	return sanitizeForTerminal(text).replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+}
+/** Escape regular-expression metacharacters so `text` matches literally. */
+function escapeRegExp(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function formatAsTable(rows, columns) {
-	const colWidths = columns.map((c) => Math.max(c.length, ...rows.map((r) => cellText(r[c]).length)));
+	const colWidths = columns.map((c) => Math.max(sanitizeInline(c).length, ...rows.map((r) => cellText(r[c]).length)));
 	return [
-		columns.map((c, i) => c.padEnd(colWidths[i] ?? 0)).join(" | "),
+		columns.map((c, i) => sanitizeInline(c).padEnd(colWidths[i] ?? 0)).join(" | "),
 		colWidths.map((w) => "-".repeat(w)).join("-|-"),
 		rows.map((r) => columns.map((c, i) => cellText(r[c]).padEnd(colWidths[i] ?? 0)).join(" | ")).join("\n")
 	].join("\n");
@@ -90,7 +130,7 @@ async function analyzeFileContents(raw, opts = {}) {
 		});
 	}
 	if (opts.level) filtered = filtered.filter((e) => (e["level"] ?? "").toLowerCase() === opts.level.toLowerCase());
-	const byLevel = {};
+	const byLevel = Object.create(null);
 	for (const e of filtered) {
 		const l = (e.level || "info").toUpperCase();
 		byLevel[l] = (byLevel[l] || 0) + 1;
@@ -112,7 +152,7 @@ const analyzeCommand = new commander.Command("analyze").description("Analyze log
 	}
 	const result = await analyzeFileContents(node_fs.default.readFileSync(full, "utf8"), opts);
 	if (opts.format === "json") {
-		console.log(JSON.stringify(result, null, 2));
+		console.log(sanitizeForTerminal(JSON.stringify(result, null, 2)));
 		return;
 	}
 	console.log(result);
@@ -178,10 +218,10 @@ function formatTime(ts) {
 	if (!ts) return "            ";
 	try {
 		const d = new Date(String(ts));
-		if (Number.isNaN(d.getTime())) return String(ts).slice(0, 12).padEnd(12);
+		if (Number.isNaN(d.getTime())) return sanitizeInline(String(ts).slice(0, 12)).padEnd(12);
 		return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}.${String(d.getMilliseconds()).padStart(3, "0")}`;
 	} catch {
-		return String(ts).slice(0, 12).padEnd(12);
+		return sanitizeInline(String(ts).slice(0, 12)).padEnd(12);
 	}
 }
 function syntaxColorJson(line) {
@@ -204,12 +244,12 @@ function buildDetailLines(entry) {
 	if (!entry) return [picocolors.default.dim("  No entry selected")];
 	const lines = [];
 	const { stack,...rest } = entry;
-	const jsonText = JSON.stringify(rest, null, 2);
+	const jsonText = sanitizeForTerminal(JSON.stringify(rest, null, 2));
 	for (const l of jsonText.split("\n")) lines.push("  " + syntaxColorJson(l));
 	if (stack) {
 		lines.push("");
 		lines.push(picocolors.default.bold(picocolors.default.red("  ▼ STACK TRACE")));
-		for (const sl of String(stack).split("\n")) {
+		for (const sl of sanitizeForTerminal(String(stack)).split("\n")) {
 			if (!sl.trim()) continue;
 			if (sl.trim().startsWith("at ")) lines.push(coloriseStackFrame(sl));
 			else lines.push("  " + picocolors.default.red(sl.trim()));
@@ -367,18 +407,18 @@ var TUIExplorer = class {
 			}
 			const entry = this.filteredEntries[entryIdx];
 			const isSelected = entryIdx === this.selectedIndex;
-			const level = normalizeLevel(entry.level);
+			const level = sanitizeInline(normalizeLevel(entry.level));
 			const time = formatTime(entry.timestamp);
-			const msg = String(entry.message ?? "");
-			const extraFields = Object.entries(entry).filter(([k]) => ![
+			const msg = sanitizeInline(String(entry.message ?? ""));
+			const extraFieldsSafe = sanitizeInline(Object.entries(entry).filter(([k]) => ![
 				"timestamp",
 				"level",
 				"message",
 				"stack"
-			].includes(k)).map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : String(v)}`).join(" ");
+			].includes(k)).map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : String(v)}`).join(" "));
 			const msgSlot = Math.floor(msgWidth * .65);
 			const msgPart = this.truncate(msg, msgSlot);
-			const extraPart = this.truncate(extraFields, msgWidth - msgPart.length - 2);
+			const extraPart = this.truncate(extraFieldsSafe, msgWidth - msgPart.length - 2);
 			const msgDisplay = msgPart + (extraPart ? picocolors.default.dim("  " + extraPart) : "");
 			const line = ` ${time} ` + levelBadge(level) + " " + this.pad(msgDisplay, msgWidth);
 			if (isSelected) {
@@ -550,10 +590,10 @@ var TUIExplorer = class {
 			if (ext === ".csv") {
 				const entries = this.filteredEntries;
 				const allKeys = [...new Set(entries.flatMap((e) => Object.keys(e)))];
-				const header = allKeys.join(",");
+				const header = allKeys.map((k) => csvField(k)).join(",");
 				const rows = entries.map((e) => allKeys.map((k) => {
 					const v = e[k];
-					return `"${(typeof v === "string" ? v : JSON.stringify(v ?? "")).replace(/"/g, "\"\"")}"`;
+					return csvField(v, true);
 				}).join(","));
 				node_fs.default.writeFileSync(resolved, [header, ...rows].join("\n"), "utf8");
 			} else if (ext === ".ndjson" || ext === ".jsonl") node_fs.default.writeFileSync(resolved, this.filteredEntries.map((e) => JSON.stringify(e)).join("\n"), "utf8");
@@ -653,15 +693,9 @@ function exportAsCSV(entries, fields) {
 	if (entries.length === 0) return "";
 	const columns = fields || Object.keys(entries[0] || {});
 	const lines = [];
-	lines.push(columns.join(","));
+	lines.push(columns.map((c) => csvField(c)).join(","));
 	for (const entry of entries) {
-		const row = columns.map((col) => {
-			const value = entry[col];
-			if (value === void 0 || value === null) return "";
-			const str = String(value);
-			if (str.includes(",") || str.includes("\"") || str.includes("\n")) return `"${str.replace(/"/g, "\"\"")}"`;
-			return str;
-		});
+		const row = columns.map((col) => csvField(entry[col]));
 		lines.push(row.join(","));
 	}
 	return lines.join("\n");
@@ -922,6 +956,21 @@ function parseCondition(expr) {
 	}
 	return null;
 }
+/** Build a case-insensitive regex for a SQL LIKE pattern; only `%` and `_` are special. */
+function likeToRegExp(pattern) {
+	let source = "";
+	let lastWasWildcard = false;
+	for (const ch of pattern) {
+		if (ch === "%") {
+			if (!lastWasWildcard) source += ".*";
+			lastWasWildcard = true;
+			continue;
+		}
+		lastWasWildcard = false;
+		source += ch === "_" ? "." : escapeRegExp(ch);
+	}
+	return new RegExp(`^${source}$`, "i");
+}
 function matchesCondition(row, cond) {
 	const rawFieldValue = row[cond.field];
 	if (rawFieldValue === void 0) return false;
@@ -934,14 +983,8 @@ function matchesCondition(row, cond) {
 		case ">=": return Number(rawFieldValue) >= Number(cond.value);
 		case "<": return Number(rawFieldValue) < Number(cond.value);
 		case "<=": return Number(rawFieldValue) <= Number(cond.value);
-		case "LIKE": {
-			const pattern = condStr.replace(/%/g, ".*").replace(/_/g, ".");
-			return new RegExp(`^${pattern}$`, "i").test(fieldStr);
-		}
-		case "NOT LIKE": {
-			const pattern = condStr.replace(/%/g, ".*").replace(/_/g, ".");
-			return !new RegExp(`^${pattern}$`, "i").test(fieldStr);
-		}
+		case "LIKE": return likeToRegExp(condStr).test(fieldStr);
+		case "NOT LIKE": return !likeToRegExp(condStr).test(fieldStr);
 		case "IN": return cond.value.some((v) => String(rawFieldValue) === v);
 		case "NOT IN": return !cond.value.some((v) => String(rawFieldValue) === v);
 		default: return false;
@@ -961,18 +1004,19 @@ function matchesNode(row, node) {
 function runAggregation(entries, agg) {
 	const { fn, field, groupBy } = agg;
 	if (!groupBy) return picocolors.default.yellow("Aggregation requires a GROUP BY field");
-	const groups = {};
+	const groups = /* @__PURE__ */ new Map();
 	for (const entry of entries) {
 		const key = String(entry[groupBy] ?? "(empty)");
-		if (!groups[key]) groups[key] = [];
-		groups[key].push(entry);
+		const bucket = groups.get(key);
+		if (bucket) bucket.push(entry);
+		else groups.set(key, [entry]);
 	}
-	if (fn === "COUNT" || fn === "GROUP") return formatAsTable(Object.entries(groups).map(([k, v]) => ({
+	if (fn === "COUNT" || fn === "GROUP") return formatAsTable([...groups.entries()].map(([k, v]) => ({
 		[groupBy]: k,
 		count: v.length
 	})).sort((a, b) => b.count - a.count), [groupBy, "count"]);
 	if (!field) return picocolors.default.yellow("Numeric aggregation requires a field: AVG(field) BY group");
-	return formatAsTable(Object.entries(groups).map(([k, v]) => {
+	return formatAsTable([...groups.entries()].map(([k, v]) => {
 		const nums = v.map((e) => Number(e[field])).filter((n) => !Number.isNaN(n));
 		let result;
 		switch (fn) {
@@ -1012,12 +1056,12 @@ function projectRow(row, select) {
 }
 function formatResults(results, format) {
 	if (results.length === 0) return picocolors.default.yellow("No results found");
-	if (format === "json") return JSON.stringify(results, null, 2);
-	if (format === "ndjson") return results.map((r) => JSON.stringify(r)).join("\n");
+	if (format === "json") return sanitizeForTerminal(JSON.stringify(results, null, 2));
+	if (format === "ndjson") return results.map((r) => sanitizeForTerminal(JSON.stringify(r))).join("\n");
 	if (format === "table") return formatAsTable(results, Object.keys(results[0] || {}).slice(0, 6));
 	return results.map((r) => {
 		const level = (r.level || "").toUpperCase();
-		const line = JSON.stringify(r);
+		const line = sanitizeForTerminal(JSON.stringify(r));
 		if (level === "ERROR" || level === "CRITICAL") return picocolors.default.red(line);
 		if (level === "WARN") return picocolors.default.yellow(line);
 		if (level === "DEBUG" || level === "VERBOSE") return picocolors.default.gray(line);
@@ -1115,7 +1159,7 @@ const queryCommand = new commander.Command("query").description("Query log files
 					});
 					if (tailResults.length > 0) console.log(formatResults(tailResults, opts.format || "line"));
 				} catch {
-					if (!opts.sql) console.log(line);
+					if (!opts.sql) console.log(sanitizeForTerminal(line));
 				}
 			});
 			rs.on("end", () => {
@@ -1148,14 +1192,14 @@ async function searchLogs(raw, opts = {}) {
 	});
 }
 function formatSearchResults(results, format, _context) {
-	if (format === "json") return JSON.stringify(results, null, 2);
+	if (format === "json") return sanitizeForTerminal(JSON.stringify(results, null, 2));
 	if (format === "table") {
 		if (results.length === 0) return picocolors.default.yellow("No results found");
 		return formatAsTable(results, Object.keys(results[0] || {}).slice(0, 4));
 	}
 	if (results.length === 0) return picocolors.default.yellow("No results found");
 	return results.map((r, idx) => {
-		const line = JSON.stringify(r);
+		const line = sanitizeForTerminal(JSON.stringify(r));
 		return `${picocolors.default.gray(String(idx + 1) + ":")} ${line}`;
 	}).join("\n");
 }
@@ -1179,11 +1223,11 @@ const searchCommand = new commander.Command("search").description("Search log fi
 async function generateStats(raw, opts = {}) {
 	const entries = safeParseLogs(raw);
 	const group = opts.groupBy || "level";
-	const agg = {};
+	const agg = Object.create(null);
 	let minTime = null;
 	let maxTime = null;
 	for (const e of entries) {
-		const key = (e[group] || e.level || "unknown").toString().toUpperCase();
+		const key = String(e[group] || e.level || "unknown").toUpperCase();
 		agg[key] = (agg[key] || 0) + 1;
 		if (e.timestamp) {
 			const ts = new Date(e.timestamp);
@@ -1204,14 +1248,15 @@ async function generateStats(raw, opts = {}) {
 function formatStatsOutput(stats, filename) {
 	const s = stats;
 	const lines = [];
-	lines.push(picocolors.default.bold(`\nLog Statistics for ${node_path.default.basename(filename)}`));
+	lines.push(picocolors.default.bold(`\nLog Statistics for ${sanitizeInline(node_path.default.basename(filename))}`));
 	lines.push(picocolors.default.bold("=".repeat(50)));
 	lines.push(picocolors.default.cyan(`Total Entries: ${s["total"].toLocaleString()}`));
 	if (s["timeRange"]) lines.push(picocolors.default.cyan(`Time Range: ${s["timeRange"]["start"].toISOString()} - ${s["timeRange"]["end"].toISOString()}`));
 	lines.push("");
-	lines.push(picocolors.default.bold(`${s["groupBy"].charAt(0).toUpperCase() + s["groupBy"].slice(1)} Distribution:`));
+	lines.push(picocolors.default.bold(`${sanitizeInline(s["groupBy"].charAt(0).toUpperCase() + s["groupBy"].slice(1))} Distribution:`));
 	const sorted = Object.entries(s["distribution"]).sort(([, a], [, b]) => b - a);
-	for (const [key, count] of sorted) {
+	for (const [rawKey, count] of sorted) {
+		const key = sanitizeInline(rawKey);
 		const percentage = (count / s["total"] * 100).toFixed(1);
 		const bar = "█".repeat(Math.floor(count / s["total"] * 30));
 		let colorFn = picocolors.default.white;
@@ -1231,7 +1276,7 @@ const statsCommand = new commander.Command("stats").description("Show statistics
 		process.exit(2);
 	}
 	const stats = await generateStats(node_fs.default.readFileSync(full, "utf8"), opts);
-	if (opts.format === "json") console.log(JSON.stringify(stats, null, 2));
+	if (opts.format === "json") console.log(sanitizeForTerminal(JSON.stringify(stats, null, 2)));
 	else console.log(formatStatsOutput(stats, file));
 });
 
@@ -1256,17 +1301,18 @@ function applyFilter(line, filter) {
 		return line.toLowerCase().includes(filter.value.toLowerCase());
 	}
 }
-function highlightLine(line, highlight) {
+function highlightLine(rawLine, highlight) {
+	const line = sanitizeForTerminal(rawLine);
 	if (!highlight) return line;
 	try {
-		const level = (JSON.parse(line).level || "").toUpperCase();
+		const level = (JSON.parse(rawLine).level || "").toUpperCase();
 		if (level === "ERROR") return picocolors.default.red(line);
 		if (level === "WARN") return picocolors.default.yellow(line);
 		if (level === "INFO") return picocolors.default.blue(line);
 		if (level === "DEBUG") return picocolors.default.gray(line);
 		return line;
 	} catch {
-		const regex = new RegExp(highlight, "gi");
+		const regex = new RegExp(escapeRegExp(sanitizeForTerminal(highlight)), "gi");
 		return line.replace(regex, (match) => picocolors.default.bgYellow(picocolors.default.black(match)));
 	}
 }

package/dist/cloudwatch.d.mts

@@ -1,3 +1,3 @@
-import "./transport.types-B5vcyv2k.mjs";
-import { n as CloudWatchTransportConfig, t as CloudWatchTransport } from "./cloudwatch.transport-CGHY4buE.mjs";
+import "./transport.types-CtNr3D7S.mjs";
+import { n as CloudWatchTransportConfig, t as CloudWatchTransport } from "./cloudwatch.transport-Blc7Gtxt.mjs";
 export { CloudWatchTransport, CloudWatchTransportConfig };

package/dist/cloudwatch.d.ts

@@ -1,3 +1,3 @@
-import "./transport.types-BuY84TwO.js";
-import { n as CloudWatchTransportConfig, t as CloudWatchTransport } from "./cloudwatch.transport-DK_8cKd3.js";
+import "./transport.types-DqVLZTyf.js";
+import { n as CloudWatchTransportConfig, t as CloudWatchTransport } from "./cloudwatch.transport-B00st6Xv.js";
 export { CloudWatchTransport, CloudWatchTransportConfig };

package/dist/cloudwatch.js

@@ -1,6 +1,7 @@
 require('./internal-log-BUJYMZbE.js');
 require('./safe-stringify-DWo3aZp_.js');
 require('./batch-buffer-BY-mRWIK.js');
-const require_cloudwatch_transport = require('./cloudwatch.transport-pNBNWJLt.js');
+const require_cloudwatch_transport = require('./cloudwatch.transport-BO1ahxw-.js');
+require('./entry-fields-BvOLFlJ4.js');
 
 exports.CloudWatchTransport = require_cloudwatch_transport.CloudWatchTransport;

package/dist/cloudwatch.mjs

@@ -1,6 +1,7 @@
 import "./internal-log-Cm8SOWSV.mjs";
 import "./safe-stringify-DJ66tW5I.mjs";
 import "./batch-buffer-PGvSgbmd.mjs";
-import { t as CloudWatchTransport } from "./cloudwatch.transport-yBwm4OeO.mjs";
+import { t as CloudWatchTransport } from "./cloudwatch.transport-DZ6ies7g.mjs";
+import "./entry-fields-BJkuPnIg.mjs";
 
 export { CloudWatchTransport };

package/dist/{cloudwatch.transport-CGHY4buE.d.mts → cloudwatch.transport-B00st6Xv.d.ts}

@@ -1,4 +1,4 @@
-import { p as TransportLogEntry, s as IAsyncTransport } from "./transport.types-B5vcyv2k.mjs";
+import { p as TransportLogEntry, s as IAsyncTransport } from "./transport.types-DqVLZTyf.js";
 
 //#region src/transports/cloudwatch.transport.d.ts
 
@@ -36,6 +36,12 @@ interface CloudWatchTransportConfig {
   emf?: boolean;
   /** CloudWatch Metrics namespace used by EMF. @default 'Logixia' */
   emfNamespace?: string;
+  /**
+   * Payload fields published as EMF metrics. When set, only these numeric
+   * fields become metrics; when unset every numeric payload field does (up to
+   * the EMF limit of 100 per entry).
+   */
+  emfMetrics?: string[];
   /** Abort a request that has not finished after this many ms. @default 10000 */
   requestTimeoutMs?: number;
   /** Max buffered events; the oldest are dropped past this. @default 10000 */
@@ -62,6 +68,7 @@ declare class CloudWatchTransport implements IAsyncTransport {
   private readonly logStreamName;
   private readonly emf;
   private readonly emfNamespace;
+  private readonly emfMetrics;
   constructor(config: CloudWatchTransportConfig);
   write(entry: TransportLogEntry): void;
   flush(): Promise<void>;
@@ -78,4 +85,4 @@ declare class CloudWatchTransport implements IAsyncTransport {
 }
 //#endregion
 export { CloudWatchTransportConfig as n, CloudWatchTransport as t };
-//# sourceMappingURL=cloudwatch.transport-CGHY4buE.d.mts.map
+//# sourceMappingURL=cloudwatch.transport-B00st6Xv.d.ts.map

package/dist/cloudwatch.transport-B00st6Xv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudwatch.transport-B00st6Xv.d.ts","names":[],"sources":["../src/transports/cloudwatch.transport.ts"],"sourcesContent":[],"mappings":";;;;UA+CiB,yBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+EJ,mBAAA,YAA+B;;;;;;;;;;;;;;;;;sBAoBtB;eAiCP;WAOJ;;;;;;WASM"}