@safaricom-mxl/log 0.0.3

package/dist/next/client.d.mts

@@ -0,0 +1,55 @@
+import { TransportConfig } from "../types.mjs";
+import { clearIdentity, log as _clientLog, setIdentity } from "../runtime/client/log.mjs";
+import * as react from "react";
+
+//#region src/next/client.d.ts
+interface MxllogProviderProps {
+  /**
+   * Service name for client-side logs.
+   * @default 'client'
+   */
+  service?: string;
+  /**
+   * Enable pretty printing in the browser console.
+   * @default true
+   */
+  pretty?: boolean;
+  /**
+   * Transport configuration for sending client logs to the server.
+   */
+  transport?: TransportConfig;
+  /**
+   * Enable or disable client-side logging.
+   * @default true
+   */
+  enabled?: boolean;
+  children: React.ReactNode;
+}
+/**
+ * React provider that initializes mxllog client-side logging.
+ * Place this in your root layout to enable client logging throughout your app.
+ *
+ * @example
+ * ```tsx
+ * // app/layout.tsx
+ * import { MxllogProvider } from '@safaricom-mxl/log/next/client'
+ *
+ * export default function Layout({ children }) {
+ *   return (
+ *     <MxllogProvider service="my-app" transport={{ enabled: true }}>
+ *       {children}
+ *     </MxllogProvider>
+ *   )
+ * }
+ * ```
+ */
+declare function MxllogProvider({
+  service,
+  pretty,
+  transport,
+  enabled,
+  children
+}: MxllogProviderProps): react.ReactNode;
+//#endregion
+export { MxllogProvider, MxllogProviderProps, clearIdentity, _clientLog as log, setIdentity };
+//# sourceMappingURL=client.d.mts.map

package/dist/next/client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.mts","names":[],"sources":["../../src/next/client.ts"],"mappings":";;;;;UAQiB,mBAAA;;;AAAjB;;EAKE,OAAA;EAmByB;;;;EAbzB,MAAA;EAWA;;;EANA,SAAA,GAAY,eAAA;EAQa;;AAsB3B;;EAxBE,OAAA;EAEA,QAAA,EAAU,KAAA,CAAM,SAAA;AAAA;;;;;;;;;;;;;;;;;;;iBAsBF,cAAA,CAAA;EAAiB,OAAA;EAAS,MAAA;EAAQ,SAAA;EAAW,OAAA;EAAS;AAAA,GAAY,mBAAA,GAAmB,KAAA,CAAA,SAAA"}

package/dist/next/client.mjs

@@ -0,0 +1,44 @@
+'use client';
+
+import { clearIdentity, initLog, log as _clientLog, setIdentity } from "../runtime/client/log.mjs";
+import { useEffect } from "react";
+
+//#region src/next/client.ts
+/**
+* React provider that initializes mxllog client-side logging.
+* Place this in your root layout to enable client logging throughout your app.
+*
+* @example
+* ```tsx
+* // app/layout.tsx
+* import { MxllogProvider } from '@safaricom-mxl/log/next/client'
+*
+* export default function Layout({ children }) {
+*   return (
+*     <MxllogProvider service="my-app" transport={{ enabled: true }}>
+*       {children}
+*     </MxllogProvider>
+*   )
+* }
+* ```
+*/
+function MxllogProvider({ service, pretty, transport, enabled, children }) {
+	useEffect(() => {
+		initLog({
+			enabled,
+			pretty,
+			service,
+			transport
+		});
+	}, [
+		enabled,
+		pretty,
+		service,
+		transport
+	]);
+	return children;
+}
+
+//#endregion
+export { MxllogProvider, clearIdentity, _clientLog as log, setIdentity };
+//# sourceMappingURL=client.mjs.map

package/dist/next/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../../src/next/client.ts"],"sourcesContent":["'use client'\n\nimport { useEffect } from 'react'\nimport type { TransportConfig } from '../types'\nimport { initLog, log, setIdentity, clearIdentity } from '../runtime/client/log'\n\nexport { log, setIdentity, clearIdentity } from '../runtime/client/log'\n\nexport interface MxllogProviderProps {\n  /**\n   * Service name for client-side logs.\n   * @default 'client'\n   */\n  service?: string\n\n  /**\n   * Enable pretty printing in the browser console.\n   * @default true\n   */\n  pretty?: boolean\n\n  /**\n   * Transport configuration for sending client logs to the server.\n   */\n  transport?: TransportConfig\n\n  /**\n   * Enable or disable client-side logging.\n   * @default true\n   */\n  enabled?: boolean\n\n  children: React.ReactNode\n}\n\n/**\n * React provider that initializes mxllog client-side logging.\n * Place this in your root layout to enable client logging throughout your app.\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import { MxllogProvider } from '@safaricom-mxl/log/next/client'\n *\n * export default function Layout({ children }) {\n *   return (\n *     <MxllogProvider service=\"my-app\" transport={{ enabled: true }}>\n *       {children}\n *     </MxllogProvider>\n *   )\n * }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function MxllogProvider({ service, pretty, transport, enabled, children }: MxllogProviderProps) {\n  useEffect(() => {\n    initLog({\n      enabled,\n      pretty,\n      service,\n      transport,\n    })\n  }, [enabled, pretty, service, transport])\n\n  return children\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAsDA,SAAgB,eAAe,EAAE,SAAS,QAAQ,WAAW,SAAS,YAAiC;AACrG,iBAAgB;AACd,UAAQ;GACN;GACA;GACA;GACA;GACD,CAAC;IACD;EAAC;EAAS;EAAQ;EAAS;EAAU,CAAC;AAEzC,QAAO"}

package/dist/next/index.d.mts

@@ -0,0 +1,169 @@
+import { DrainContext, EnrichContext, EnvironmentContext, Log, RequestLogger, RouteConfig, SamplingConfig, TailSamplingContext } from "../types.mjs";
+import { createError } from "../error.mjs";
+import { log as _log } from "../logger.mjs";
+import "../index.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/next/types.d.ts
+interface NextMxllogOptions {
+  /**
+   * Service name for all logged events.
+   * @default auto-detected from SERVICE_NAME env or 'app'
+   */
+  service?: string;
+  /**
+   * Environment context overrides.
+   */
+  env?: Partial<EnvironmentContext>;
+  /**
+   * Enable pretty printing.
+   * @default true in development, false in production
+   */
+  pretty?: boolean;
+  /**
+   * Enable or disable all logging globally.
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Sampling configuration for filtering logs.
+   */
+  sampling?: SamplingConfig;
+  /**
+   * Route patterns to include in logging.
+   * Supports glob patterns like '/api/**'.
+   * If not set, all routes are logged.
+   */
+  include?: string[];
+  /**
+   * Route patterns to exclude from logging.
+   * Supports glob patterns like '/_next/**'.
+   * Exclusions take precedence over inclusions.
+   */
+  exclude?: string[];
+  /**
+   * Route-specific service configuration.
+   */
+  routes?: Record<string, RouteConfig>;
+  /**
+   * Drain callback called with every emitted event (fire-and-forget).
+   * Compatible with drain adapters and pipeline-wrapped drains.
+   */
+  drain?: (ctx: DrainContext) => void | Promise<void>;
+  /**
+   * Enrich callback called after emit, before drain.
+   * Use this to add derived context (e.g. geo, deployment info).
+   */
+  enrich?: (ctx: EnrichContext) => void | Promise<void>;
+  /**
+   * Custom tail sampling callback called before emit.
+   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.
+   * Equivalent to Nuxt's `mxllog:emit:keep` hook.
+   */
+  keep?: (ctx: TailSamplingContext) => void | Promise<void>;
+  /**
+   * When pretty is disabled, emit JSON strings (default) or raw objects.
+   * @default true
+   */
+  stringify?: boolean;
+}
+interface MxllogMiddlewareConfig {
+  /**
+   * Route patterns to include in middleware processing.
+   * Supports glob patterns like '/api/**'.
+   */
+  include?: string[];
+  /**
+   * Route patterns to exclude from middleware processing.
+   * Supports glob patterns like '/_next/**'.
+   */
+  exclude?: string[];
+}
+//#endregion
+//#region src/next/storage.d.ts
+/**
+ * Get the current request-scoped logger.
+ * Must be called inside a `withMxllog()` wrapper.
+ *
+ * @throws {Error} if called outside of `withMxllog()` context
+ *
+ * @example
+ * ```ts
+ * export const POST = withMxllog(async (request) => {
+ *   const log = useLogger()
+ *   log.set({ user: { id: '123' } })
+ *   return Response.json({ ok: true })
+ * })
+ * ```
+ */
+declare function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T>;
+//#endregion
+//#region src/next/middleware.d.ts
+type NextRequest = {
+  nextUrl: {
+    pathname: string;
+  };
+  headers: {
+    get(name: string): string | null;
+  };
+};
+type NextResponse = {
+  headers: {
+    set(name: string, value: string): void;
+  };
+};
+/**
+ * Create an mxllog middleware for Next.js.
+ * Sets `x-request-id` and `x-mxllog-start` headers so `withMxllog()` can reuse them
+ * for timing consistency across the middleware -> handler chain.
+ *
+ * @example
+ * ```ts
+ * // middleware.ts
+ * import { mxllogMiddleware } from '@safaricom-mxl/log/next'
+ * export const middleware = mxllogMiddleware()
+ * export const config = { matcher: ['/api/:path*'] }
+ * ```
+ */
+declare function mxllogMiddleware(config?: MxllogMiddlewareConfig): (request: NextRequest) => Promise<NextResponse>;
+//#endregion
+//#region src/next/index.d.ts
+/**
+ * Create an mxllog instance configured for Next.js.
+ * Returns all helpers needed for server-side logging.
+ *
+ * @example
+ * ```ts
+ * // lib/mxllog.ts
+ * import { createMxllog } from '@safaricom-mxl/log/next'
+ * import { createAxiomDrain } from '@safaricom-mxl/log/axiom'
+ * import { createDrainPipeline } from '@safaricom-mxl/log/pipeline'
+ *
+ * const pipeline = createDrainPipeline({ batch: { size: 50 } })
+ *
+ * export const { withMxllog, useLogger, log, createMxllogError } = createMxllog({
+ *   service: 'my-app',
+ *   sampling: {
+ *     rates: { info: 10 },
+ *     keep: [{ status: 400 }, { duration: 1000 }],
+ *   },
+ *   drain: pipeline(createAxiomDrain({
+ *     dataset: 'logs',
+ *     token: process.env.AXIOM_TOKEN!,
+ *   })),
+ *   enrich: (ctx) => {
+ *     ctx.event.deploymentId = process.env.VERCEL_DEPLOYMENT_ID
+ *   },
+ * })
+ * ```
+ */
+declare function createMxllog(options?: NextMxllogOptions): {
+  withMxllog: <TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => TReturn) => (...args: TArgs) => Promise<Awaited<TReturn>>;
+  useLogger: typeof useLogger;
+  log: Log;
+  createError: typeof createError;
+  createMxllogError: typeof createError;
+};
+//#endregion
+export { type MxllogMiddlewareConfig, type NextMxllogOptions, createError, createError as createMxllogError, createMxllog, _log as log, mxllogMiddleware, useLogger };
+//# sourceMappingURL=index.d.mts.map

package/dist/next/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/next/types.ts","../../src/next/storage.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"mappings":";;;;;;;UAEiB,iBAAA;;;;;EAKf,OAAA;EALe;;;EAUf,GAAA,GAAM,OAAA,CAAQ,kBAAA;EAAR;;;;EAMN,MAAA;EAoCsC;;;;EA9BtC,OAAA;EA2CmD;;;EAtCnD,QAAA,GAAW,cAAA;EAjBL;;;;;EAwBN,OAAA;EAAA;;;;;EAOA,OAAA;EAWc;;;EANd,MAAA,GAAS,MAAA,SAAe,WAAA;EAYT;;;;EANf,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAa9B;;;;EAPR,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EAgBzB;;;;;EATf,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;;;AC/C9C;;EDqDE,SAAA;AAAA;AAAA,UAGe,sBAAA;ECxDwD;;;;ED6DvE,OAAA;EC7DuE;;;;EDmEvE,OAAA;AAAA;;;;;;;AArFF;;;;;;;;;;;iBCkBgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;;;KCjBlF,WAAA;EACH,OAAA;IAAW,QAAA;EAAA;EACX,OAAA;IAAW,GAAA,CAAI,IAAA;EAAA;AAAA;AAAA,KAGZ,YAAA;EACH,OAAA;IAAW,GAAA,CAAI,IAAA,UAAc,KAAA;EAAA;AAAA;;;;;;;;;;;;;;iBAoBf,gBAAA,CAAiB,MAAA,GAAS,sBAAA,IAC1B,OAAA,EAAS,WAAA,KAAW,OAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCYpB,YAAA,CAAa,OAAA,GAAS,iBAAA;8DAWo5D,IAAA,EAAA,KAAA,KAAA,OAAA,SAAkC,IAAA,EAAA,KAAA,KAAA,OAAA,CAAA,OAAA,CAAA,OAAA"}

package/dist/next/index.mjs

@@ -0,0 +1,280 @@
+import { filterSafeHeaders } from "../utils.mjs";
+import { MxllogError, createError } from "../error.mjs";
+import { createRequestLogger, initLogger, isEnabled, log as _log } from "../logger.mjs";
+import { n as shouldLog, t as getServiceForPath } from "../routes-BNbrnm14.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/next/storage.ts
+const mxllogStorage = new AsyncLocalStorage();
+/**
+* Get the current request-scoped logger.
+* Must be called inside a `withMxllog()` wrapper.
+*
+* @throws {Error} if called outside of `withMxllog()` context
+*
+* @example
+* ```ts
+* export const POST = withMxllog(async (request) => {
+*   const log = useLogger()
+*   log.set({ user: { id: '123' } })
+*   return Response.json({ ok: true })
+* })
+* ```
+*/
+function useLogger() {
+	const logger = mxllogStorage.getStore();
+	if (!logger) throw new Error("[mxllog] useLogger() was called outside of a withMxllog() context. Wrap your route handler or server action with withMxllog().");
+	return logger;
+}
+
+//#endregion
+//#region src/next/handler.ts
+const state = {
+	initialized: false,
+	options: {}
+};
+function configureHandler(options) {
+	state.options = options;
+	state.initialized = true;
+	initLogger({
+		enabled: options.enabled,
+		env: {
+			service: options.service,
+			...options.env
+		},
+		pretty: options.pretty,
+		sampling: options.sampling,
+		stringify: options.stringify
+	});
+}
+function extractRequestInfo(request) {
+	const { method } = request;
+	const path = new URL(request.url, "http://localhost").pathname;
+	const headers = {};
+	request.headers.forEach((value, key) => {
+		headers[key] = value;
+	});
+	return {
+		method,
+		path,
+		headers: filterSafeHeaders(headers)
+	};
+}
+async function callEnrichAndDrain(emittedEvent, requestInfo, headers, responseStatus) {
+	if (!emittedEvent) return;
+	const { enrich, drain } = state.options;
+	const run = async () => {
+		if (enrich) {
+			const enrichCtx = {
+				event: emittedEvent,
+				request: requestInfo,
+				headers,
+				response: { status: responseStatus }
+			};
+			try {
+				await enrich(enrichCtx);
+			} catch (err) {
+				console.error("[mxllog] enrich failed:", err);
+			}
+		}
+		if (drain) {
+			const drainCtx = {
+				event: emittedEvent,
+				request: requestInfo,
+				headers
+			};
+			try {
+				await drain(drainCtx);
+			} catch (err) {
+				console.error("[mxllog] drain failed:", err);
+			}
+		}
+	};
+	try {
+		const { after } = await import("next/server");
+		if (typeof after === "function") {
+			after(run);
+			return;
+		}
+	} catch {}
+	run().catch(() => {});
+}
+/**
+* Wrap a Next.js route handler or server action with mxllog request-scoped logging.
+*
+* @example
+* ```ts
+* // Route handler
+* export const POST = withMxllog(async (request: NextRequest) => {
+*   const log = useLogger()
+*   log.set({ user: { id: '123' } })
+*   return Response.json({ success: true })
+* })
+*
+* // Server action
+* export const checkout = withMxllog(async (formData: FormData) => {
+*   const log = useLogger()
+*   log.set({ action: 'checkout' })
+* })
+* ```
+*/
+function createWithMxllog(options) {
+	configureHandler(options);
+	return function withMxllog(handler) {
+		return async (...args) => {
+			if (!isEnabled()) return await handler(...args);
+			const [firstArg] = args;
+			const isRequest = firstArg instanceof Request;
+			let method = "UNKNOWN";
+			let path = "/";
+			let headers = {};
+			let requestId = crypto.randomUUID();
+			if (isRequest) {
+				({method, path, headers} = extractRequestInfo(firstArg));
+				const middlewareRequestId = firstArg.headers.get("x-request-id");
+				if (middlewareRequestId) requestId = middlewareRequestId;
+			}
+			if (!shouldLog(path, state.options.include, state.options.exclude)) return await handler(...args);
+			const logger = createRequestLogger({
+				method,
+				path,
+				requestId
+			});
+			const routeService = getServiceForPath(path, state.options.routes);
+			if (routeService) logger.set({ service: routeService });
+			if (isRequest) {
+				const startHeader = firstArg.headers.get("x-mxllog-start");
+				if (startHeader) logger.set({ middlewareStart: Number(startHeader) });
+			}
+			try {
+				const result = await mxllogStorage.run(logger, () => handler(...args));
+				let { status } = { status: 200 };
+				if (result instanceof Response) ({status} = result);
+				logger.set({ status });
+				let forceKeep = false;
+				if (state.options.keep) try {
+					const tailCtx = {
+						status,
+						path,
+						method,
+						context: logger.getContext(),
+						shouldKeep: false
+					};
+					await state.options.keep(tailCtx);
+					forceKeep = tailCtx.shouldKeep ?? false;
+				} catch (err) {
+					console.error("[mxllog] keep callback failed:", err);
+				}
+				await callEnrichAndDrain(logger.emit({ _forceKeep: forceKeep }), {
+					method,
+					path,
+					requestId
+				}, headers, status);
+				return result;
+			} catch (error) {
+				logger.error(error instanceof Error ? error : new Error(String(error)));
+				const errorStatus = error.status ?? error.statusCode ?? 500;
+				logger.set({ status: errorStatus });
+				let forceKeep = false;
+				if (state.options.keep) try {
+					const tailCtx = {
+						status: errorStatus,
+						path,
+						method,
+						context: logger.getContext(),
+						shouldKeep: false
+					};
+					await state.options.keep(tailCtx);
+					forceKeep = tailCtx.shouldKeep ?? false;
+				} catch (err) {
+					console.error("[mxllog] keep callback failed:", err);
+				}
+				await callEnrichAndDrain(logger.emit({ _forceKeep: forceKeep }), {
+					method,
+					path,
+					requestId
+				}, headers, errorStatus);
+				if (isRequest && error instanceof MxllogError) return Response.json(error.toJSON(), { status: error.status });
+				throw error;
+			}
+		};
+	};
+}
+
+//#endregion
+//#region src/next/middleware.ts
+/**
+* Create an mxllog middleware for Next.js.
+* Sets `x-request-id` and `x-mxllog-start` headers so `withMxllog()` can reuse them
+* for timing consistency across the middleware -> handler chain.
+*
+* @example
+* ```ts
+* // middleware.ts
+* import { mxllogMiddleware } from '@safaricom-mxl/log/next'
+* export const middleware = mxllogMiddleware()
+* export const config = { matcher: ['/api/:path*'] }
+* ```
+*/
+function mxllogMiddleware(config) {
+	return async (request) => {
+		const path = request.nextUrl.pathname;
+		if (!shouldLog(path, config?.include, config?.exclude)) {
+			const { NextResponse: nextResponse } = await import("next/server");
+			return nextResponse.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-mxllog-start", String(Date.now()));
+		const { NextResponse: nextResponse } = await import("next/server");
+		const response = nextResponse.next({ request: { headers: requestHeaders } });
+		response.headers.set("x-request-id", requestId);
+		return response;
+	};
+}
+
+//#endregion
+//#region src/next/index.ts
+/**
+* Create an mxllog instance configured for Next.js.
+* Returns all helpers needed for server-side logging.
+*
+* @example
+* ```ts
+* // lib/mxllog.ts
+* import { createMxllog } from '@safaricom-mxl/log/next'
+* import { createAxiomDrain } from '@safaricom-mxl/log/axiom'
+* import { createDrainPipeline } from '@safaricom-mxl/log/pipeline'
+*
+* const pipeline = createDrainPipeline({ batch: { size: 50 } })
+*
+* export const { withMxllog, useLogger, log, createMxllogError } = createMxllog({
+*   service: 'my-app',
+*   sampling: {
+*     rates: { info: 10 },
+*     keep: [{ status: 400 }, { duration: 1000 }],
+*   },
+*   drain: pipeline(createAxiomDrain({
+*     dataset: 'logs',
+*     token: process.env.AXIOM_TOKEN!,
+*   })),
+*   enrich: (ctx) => {
+*     ctx.event.deploymentId = process.env.VERCEL_DEPLOYMENT_ID
+*   },
+* })
+* ```
+*/
+function createMxllog(options = {}) {
+	return {
+		withMxllog: createWithMxllog(options),
+		useLogger,
+		log: _log,
+		createError,
+		createMxllogError: createError
+	};
+}
+
+//#endregion
+export { createError, createError as createMxllogError, createMxllog, _log as log, mxllogMiddleware, useLogger };
+//# sourceMappingURL=index.mjs.map

package/dist/next/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/next/storage.ts","../../src/next/handler.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\n\nexport const mxllogStorage = new AsyncLocalStorage<RequestLogger>()\n\n/**\n * Get the current request-scoped logger.\n * Must be called inside a `withMxllog()` wrapper.\n *\n * @throws {Error} if called outside of `withMxllog()` context\n *\n * @example\n * ```ts\n * export const POST = withMxllog(async (request) => {\n *   const log = useLogger()\n *   log.set({ user: { id: '123' } })\n *   return Response.json({ ok: true })\n * })\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n  const logger = mxllogStorage.getStore()\n  if (!logger) {\n    throw new Error(\n      '[mxllog] useLogger() was called outside of a withMxllog() context. '\n      + 'Wrap your route handler or server action with withMxllog().',\n    )\n  }\n  return logger as RequestLogger<T>\n}\n","import type { DrainContext, EnrichContext, TailSamplingContext, WideEvent } from '../types'\nimport { createRequestLogger, initLogger, isEnabled } from '../logger'\nimport { filterSafeHeaders } from '../utils'\nimport { shouldLog, getServiceForPath } from '../shared/routes'\nimport { MxllogError } from '../error'\nimport type { NextMxllogOptions } from './types'\nimport { mxllogStorage } from './storage'\n\ninterface WithMxllogState {\n  initialized: boolean\n  options: NextMxllogOptions\n}\n\nconst state: WithMxllogState = {\n  initialized: false,\n  options: {},\n}\n\nexport function configureHandler(options: NextMxllogOptions): void {\n  state.options = options\n  state.initialized = true\n\n  // Don't pass drain to initLogger — the global drain fires inside emitWideEvent\n  // which doesn't have request/header context. Instead, we call drain ourselves\n  // in callEnrichAndDrain after enrich, with full context.\n  initLogger({\n    enabled: options.enabled,\n    env: {\n      service: options.service,\n      ...options.env,\n    },\n    pretty: options.pretty,\n    sampling: options.sampling,\n    stringify: options.stringify,\n  })\n}\n\nfunction extractRequestInfo(request: Request): { method: string, path: string, headers: Record<string, string> } {\n  const { method } = request\n  const url = new URL(request.url, 'http://localhost')\n  const path = url.pathname\n\n  const headers: Record<string, string> = {}\n  request.headers.forEach((value, key) => {\n    headers[key] = value\n  })\n\n  return { method, path, headers: filterSafeHeaders(headers) }\n}\n\nasync function callEnrichAndDrain(\n  emittedEvent: WideEvent | null,\n  requestInfo: { method: string, path: string, requestId: string },\n  headers: Record<string, string>,\n  responseStatus?: number,\n): Promise<void> {\n  if (!emittedEvent) return\n\n  const { enrich, drain } = state.options\n\n  const run = async () => {\n    if (enrich) {\n      const enrichCtx: EnrichContext = {\n        event: emittedEvent,\n        request: requestInfo,\n        headers,\n        response: { status: responseStatus },\n      }\n      try {\n        await enrich(enrichCtx)\n      } catch (err) {\n        console.error('[mxllog] enrich failed:', err)\n      }\n    }\n\n    if (drain) {\n      const drainCtx: DrainContext = {\n        event: emittedEvent,\n        request: requestInfo,\n        headers,\n      }\n      try {\n        await drain(drainCtx)\n      } catch (err) {\n        console.error('[mxllog] drain failed:', err)\n      }\n    }\n  }\n\n  // Use next/server after() if available to run enrich+drain after response\n  try {\n    const { after } = await import('next/server')\n    if (typeof after === 'function') {\n      after(run)\n      return\n    }\n  } catch {\n    // next/server not available or after() not exported — run inline\n  }\n\n  // Fallback: fire-and-forget (enrich still awaited for correctness)\n  run().catch(() => {})\n}\n\n/**\n * Wrap a Next.js route handler or server action with mxllog request-scoped logging.\n *\n * @example\n * ```ts\n * // Route handler\n * export const POST = withMxllog(async (request: NextRequest) => {\n *   const log = useLogger()\n *   log.set({ user: { id: '123' } })\n *   return Response.json({ success: true })\n * })\n *\n * // Server action\n * export const checkout = withMxllog(async (formData: FormData) => {\n *   const log = useLogger()\n *   log.set({ action: 'checkout' })\n * })\n * ```\n */\nexport function createWithMxllog(options: NextMxllogOptions) {\n  configureHandler(options)\n\n  return function withMxllog<TArgs extends unknown[], TReturn>(\n    handler: (...args: TArgs) => TReturn,\n  ): (...args: TArgs) => Promise<Awaited<TReturn>> {\n    return async (...args: TArgs): Promise<Awaited<TReturn>> => {\n      if (!isEnabled()) {\n        return await handler(...args) as Awaited<TReturn>\n      }\n\n      // Extract request info from first argument if it's a Request\n      const [firstArg] = args\n      const isRequest = firstArg instanceof Request\n\n      let method = 'UNKNOWN'\n      let path = '/'\n      let headers: Record<string, string> = {}\n      let requestId = crypto.randomUUID()\n\n      if (isRequest) {\n        ({ method, path, headers } = extractRequestInfo(firstArg))\n\n        // Reuse request-id from middleware if present\n        const middlewareRequestId = firstArg.headers.get('x-request-id')\n        if (middlewareRequestId) requestId = middlewareRequestId\n      }\n\n      // Check include/exclude patterns\n      if (!shouldLog(path, state.options.include, state.options.exclude)) {\n        return await handler(...args) as Awaited<TReturn>\n      }\n\n      const logger = createRequestLogger({ method, path, requestId })\n\n      // Apply route-based service configuration\n      const routeService = getServiceForPath(path, state.options.routes)\n      if (routeService) {\n        logger.set({ service: routeService })\n      }\n\n      // Apply start time from middleware if present\n      if (isRequest) {\n        const startHeader = firstArg.headers.get('x-mxllog-start')\n        if (startHeader) {\n          logger.set({ middlewareStart: Number(startHeader) })\n        }\n      }\n\n      try {\n        const result = await mxllogStorage.run(logger, () => handler(...args))\n\n        // Extract response status\n        let { status } = { status: 200 }\n        if (result instanceof Response) {\n          ({ status } = result)\n        }\n        logger.set({ status })\n\n        // Build tail sampling context and call keep callback\n        let forceKeep = false\n        if (state.options.keep) {\n          try {\n            const tailCtx: TailSamplingContext = {\n              status,\n              path,\n              method,\n              context: logger.getContext(),\n              shouldKeep: false,\n            }\n            await state.options.keep(tailCtx)\n            forceKeep = tailCtx.shouldKeep ?? false\n          } catch (err) {\n            console.error('[mxllog] keep callback failed:', err)\n          }\n        }\n\n        const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n        await callEnrichAndDrain(emittedEvent, { method, path, requestId }, headers, status)\n\n        return result as Awaited<TReturn>\n      } catch (error) {\n        logger.error(error instanceof Error ? error : new Error(String(error)))\n\n        const errorStatus = (error as { status?: number }).status\n          ?? (error as { statusCode?: number }).statusCode\n          ?? 500\n        logger.set({ status: errorStatus })\n\n        // Build tail sampling context and call keep callback\n        let forceKeep = false\n        if (state.options.keep) {\n          try {\n            const tailCtx: TailSamplingContext = {\n              status: errorStatus,\n              path,\n              method,\n              context: logger.getContext(),\n              shouldKeep: false,\n            }\n            await state.options.keep(tailCtx)\n            forceKeep = tailCtx.shouldKeep ?? false\n          } catch (err) {\n            console.error('[mxllog] keep callback failed:', err)\n          }\n        }\n\n        const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n        await callEnrichAndDrain(emittedEvent, { method, path, requestId }, headers, errorStatus)\n\n        // Return structured JSON response for MxllogErrors (like H3 does for Nuxt)\n        if (isRequest && error instanceof MxllogError) {\n          return Response.json(error.toJSON(), { status: error.status }) as Awaited<TReturn>\n        }\n\n        throw error\n      }\n    }\n  }\n}\n","import { shouldLog } from '../shared/routes'\nimport type { MxllogMiddlewareConfig } from './types'\n\ntype NextRequest = {\n  nextUrl: { pathname: string }\n  headers: { get(name: string): string | null }\n}\n\ntype NextResponse = {\n  headers: { set(name: string, value: string): void }\n}\n\ntype NextResponseStatic = {\n  next(options?: { request?: { headers: Headers } }): NextResponse\n}\n\n/**\n * Create an mxllog middleware for Next.js.\n * Sets `x-request-id` and `x-mxllog-start` headers so `withMxllog()` can reuse them\n * for timing consistency across the middleware -> handler chain.\n *\n * @example\n * ```ts\n * // middleware.ts\n * import { mxllogMiddleware } from '@safaricom-mxl/log/next'\n * export const middleware = mxllogMiddleware()\n * export const config = { matcher: ['/api/:path*'] }\n * ```\n */\nexport function mxllogMiddleware(config?: MxllogMiddlewareConfig) {\n  return async (request: NextRequest) => {\n    const path = request.nextUrl.pathname\n\n    // Check include/exclude patterns\n    if (!shouldLog(path, config?.include, config?.exclude)) {\n      const { NextResponse: nextResponse } = await import('next/server') as { NextResponse: NextResponseStatic }\n      return nextResponse.next()\n    }\n\n    // Generate or reuse request ID\n    const existingId = request.headers.get('x-request-id')\n    const requestId = existingId || crypto.randomUUID()\n\n    // Forward modified headers to the route handler\n    const requestHeaders = new Headers(request.headers as HeadersInit)\n\n    requestHeaders.set('x-request-id', requestId)\n    requestHeaders.set('x-mxllog-start', String(Date.now()))\n\n    const { NextResponse: nextResponse } = await import('next/server') as { NextResponse: NextResponseStatic }\n    const response = nextResponse.next({\n      request: { headers: requestHeaders },\n    })\n\n    // Also set on response for downstream consumers\n    response.headers.set('x-request-id', requestId)\n\n    return response\n  }\n}\n","import { log } from '../logger'\nimport { createError, createMxllogError } from '../error'\nimport type { NextMxllogOptions } from './types'\nimport { createWithMxllog } from './handler'\nimport { useLogger } from './storage'\n\nexport type { NextMxllogOptions, MxllogMiddlewareConfig } from './types'\n\nexport { mxllogMiddleware } from './middleware'\nexport { useLogger } from './storage'\nexport { log } from '../logger'\nexport { createError, createMxllogError } from '../error'\n\n/**\n * Create an mxllog instance configured for Next.js.\n * Returns all helpers needed for server-side logging.\n *\n * @example\n * ```ts\n * // lib/mxllog.ts\n * import { createMxllog } from '@safaricom-mxl/log/next'\n * import { createAxiomDrain } from '@safaricom-mxl/log/axiom'\n * import { createDrainPipeline } from '@safaricom-mxl/log/pipeline'\n *\n * const pipeline = createDrainPipeline({ batch: { size: 50 } })\n *\n * export const { withMxllog, useLogger, log, createMxllogError } = createMxllog({\n *   service: 'my-app',\n *   sampling: {\n *     rates: { info: 10 },\n *     keep: [{ status: 400 }, { duration: 1000 }],\n *   },\n *   drain: pipeline(createAxiomDrain({\n *     dataset: 'logs',\n *     token: process.env.AXIOM_TOKEN!,\n *   })),\n *   enrich: (ctx) => {\n *     ctx.event.deploymentId = process.env.VERCEL_DEPLOYMENT_ID\n *   },\n * })\n * ```\n */\nexport function createMxllog(options: NextMxllogOptions = {}) {\n  const withMxllog = createWithMxllog(options)\n\n  return {\n    withMxllog,\n    useLogger,\n    log,\n    createError,\n    createMxllogError,\n  }\n}\n"],"mappings":";;;;;;;AAGA,MAAa,gBAAgB,IAAI,mBAAkC;;;;;;;;;;;;;;;;AAiBnE,SAAgB,YAA0E;CACxF,MAAM,SAAS,cAAc,UAAU;AACvC,KAAI,CAAC,OACH,OAAM,IAAI,MACR,iIAED;AAEH,QAAO;;;;;ACfT,MAAM,QAAyB;CAC7B,aAAa;CACb,SAAS,EAAE;CACZ;AAED,SAAgB,iBAAiB,SAAkC;AACjE,OAAM,UAAU;AAChB,OAAM,cAAc;AAKpB,YAAW;EACT,SAAS,QAAQ;EACjB,KAAK;GACH,SAAS,QAAQ;GACjB,GAAG,QAAQ;GACZ;EACD,QAAQ,QAAQ;EAChB,UAAU,QAAQ;EAClB,WAAW,QAAQ;EACpB,CAAC;;AAGJ,SAAS,mBAAmB,SAAqF;CAC/G,MAAM,EAAE,WAAW;CAEnB,MAAM,OADM,IAAI,IAAI,QAAQ,KAAK,mBAAmB,CACnC;CAEjB,MAAM,UAAkC,EAAE;AAC1C,SAAQ,QAAQ,SAAS,OAAO,QAAQ;AACtC,UAAQ,OAAO;GACf;AAEF,QAAO;EAAE;EAAQ;EAAM,SAAS,kBAAkB,QAAQ;EAAE;;AAG9D,eAAe,mBACb,cACA,aACA,SACA,gBACe;AACf,KAAI,CAAC,aAAc;CAEnB,MAAM,EAAE,QAAQ,UAAU,MAAM;CAEhC,MAAM,MAAM,YAAY;AACtB,MAAI,QAAQ;GACV,MAAM,YAA2B;IAC/B,OAAO;IACP,SAAS;IACT;IACA,UAAU,EAAE,QAAQ,gBAAgB;IACrC;AACD,OAAI;AACF,UAAM,OAAO,UAAU;YAChB,KAAK;AACZ,YAAQ,MAAM,2BAA2B,IAAI;;;AAIjD,MAAI,OAAO;GACT,MAAM,WAAyB;IAC7B,OAAO;IACP,SAAS;IACT;IACD;AACD,OAAI;AACF,UAAM,MAAM,SAAS;YACd,KAAK;AACZ,YAAQ,MAAM,0BAA0B,IAAI;;;;AAMlD,KAAI;EACF,MAAM,EAAE,UAAU,MAAM,OAAO;AAC/B,MAAI,OAAO,UAAU,YAAY;AAC/B,SAAM,IAAI;AACV;;SAEI;AAKR,MAAK,CAAC,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;AAsBvB,SAAgB,iBAAiB,SAA4B;AAC3D,kBAAiB,QAAQ;AAEzB,QAAO,SAAS,WACd,SAC+C;AAC/C,SAAO,OAAO,GAAG,SAA2C;AAC1D,OAAI,CAAC,WAAW,CACd,QAAO,MAAM,QAAQ,GAAG,KAAK;GAI/B,MAAM,CAAC,YAAY;GACnB,MAAM,YAAY,oBAAoB;GAEtC,IAAI,SAAS;GACb,IAAI,OAAO;GACX,IAAI,UAAkC,EAAE;GACxC,IAAI,YAAY,OAAO,YAAY;AAEnC,OAAI,WAAW;AACb,KAAC,CAAE,QAAQ,MAAM,WAAY,mBAAmB,SAAS;IAGzD,MAAM,sBAAsB,SAAS,QAAQ,IAAI,eAAe;AAChE,QAAI,oBAAqB,aAAY;;AAIvC,OAAI,CAAC,UAAU,MAAM,MAAM,QAAQ,SAAS,MAAM,QAAQ,QAAQ,CAChE,QAAO,MAAM,QAAQ,GAAG,KAAK;GAG/B,MAAM,SAAS,oBAAoB;IAAE;IAAQ;IAAM;IAAW,CAAC;GAG/D,MAAM,eAAe,kBAAkB,MAAM,MAAM,QAAQ,OAAO;AAClE,OAAI,aACF,QAAO,IAAI,EAAE,SAAS,cAAc,CAAC;AAIvC,OAAI,WAAW;IACb,MAAM,cAAc,SAAS,QAAQ,IAAI,iBAAiB;AAC1D,QAAI,YACF,QAAO,IAAI,EAAE,iBAAiB,OAAO,YAAY,EAAE,CAAC;;AAIxD,OAAI;IACF,MAAM,SAAS,MAAM,cAAc,IAAI,cAAc,QAAQ,GAAG,KAAK,CAAC;IAGtE,IAAI,EAAE,WAAW,EAAE,QAAQ,KAAK;AAChC,QAAI,kBAAkB,SACpB,EAAC,CAAE,UAAW;AAEhB,WAAO,IAAI,EAAE,QAAQ,CAAC;IAGtB,IAAI,YAAY;AAChB,QAAI,MAAM,QAAQ,KAChB,KAAI;KACF,MAAM,UAA+B;MACnC;MACA;MACA;MACA,SAAS,OAAO,YAAY;MAC5B,YAAY;MACb;AACD,WAAM,MAAM,QAAQ,KAAK,QAAQ;AACjC,iBAAY,QAAQ,cAAc;aAC3B,KAAK;AACZ,aAAQ,MAAM,kCAAkC,IAAI;;AAKxD,UAAM,mBADe,OAAO,KAAK,EAAE,YAAY,WAAW,CAAC,EACpB;KAAE;KAAQ;KAAM;KAAW,EAAE,SAAS,OAAO;AAEpF,WAAO;YACA,OAAO;AACd,WAAO,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC,CAAC;IAEvE,MAAM,cAAe,MAA8B,UAC7C,MAAkC,cACnC;AACL,WAAO,IAAI,EAAE,QAAQ,aAAa,CAAC;IAGnC,IAAI,YAAY;AAChB,QAAI,MAAM,QAAQ,KAChB,KAAI;KACF,MAAM,UAA+B;MACnC,QAAQ;MACR;MACA;MACA,SAAS,OAAO,YAAY;MAC5B,YAAY;MACb;AACD,WAAM,MAAM,QAAQ,KAAK,QAAQ;AACjC,iBAAY,QAAQ,cAAc;aAC3B,KAAK;AACZ,aAAQ,MAAM,kCAAkC,IAAI;;AAKxD,UAAM,mBADe,OAAO,KAAK,EAAE,YAAY,WAAW,CAAC,EACpB;KAAE;KAAQ;KAAM;KAAW,EAAE,SAAS,YAAY;AAGzF,QAAI,aAAa,iBAAiB,YAChC,QAAO,SAAS,KAAK,MAAM,QAAQ,EAAE,EAAE,QAAQ,MAAM,QAAQ,CAAC;AAGhE,UAAM;;;;;;;;;;;;;;;;;;;;;ACjNd,SAAgB,iBAAiB,QAAiC;AAChE,QAAO,OAAO,YAAyB;EACrC,MAAM,OAAO,QAAQ,QAAQ;AAG7B,MAAI,CAAC,UAAU,MAAM,QAAQ,SAAS,QAAQ,QAAQ,EAAE;GACtD,MAAM,EAAE,cAAc,iBAAiB,MAAM,OAAO;AACpD,UAAO,aAAa,MAAM;;EAK5B,MAAM,YADa,QAAQ,QAAQ,IAAI,eAAe,IACtB,OAAO,YAAY;EAGnD,MAAM,iBAAiB,IAAI,QAAQ,QAAQ,QAAuB;AAElE,iBAAe,IAAI,gBAAgB,UAAU;AAC7C,iBAAe,IAAI,kBAAkB,OAAO,KAAK,KAAK,CAAC,CAAC;EAExD,MAAM,EAAE,cAAc,iBAAiB,MAAM,OAAO;EACpD,MAAM,WAAW,aAAa,KAAK,EACjC,SAAS,EAAE,SAAS,gBAAgB,EACrC,CAAC;AAGF,WAAS,QAAQ,IAAI,gBAAgB,UAAU;AAE/C,SAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACfX,SAAgB,aAAa,UAA6B,EAAE,EAAE;AAG5D,QAAO;EACL,YAHiB,iBAAiB,QAAQ;EAI1C;EACA;EACA;EACA;EACD"}

package/dist/nitro/errorHandler.d.mts

@@ -0,0 +1,15 @@
+import * as nitropack from "nitropack";
+
+//#region src/nitro/errorHandler.d.ts
+/**
+ * Custom Nitro error handler that properly serializes MxllogError.
+ * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved
+ * in the JSON response regardless of the underlying HTTP framework.
+ *
+ * For non-MxllogError, it preserves Nitro's default response shape while
+ * sanitizing internal error details in production for 5xx errors.
+ */
+declare const _default: nitropack.NitroErrorHandler;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=errorHandler.d.mts.map

package/dist/nitro/errorHandler.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandler.d.mts","names":[],"sources":["../../src/nitro/errorHandler.ts"],"mappings":""}

package/dist/nitro/errorHandler.mjs

@@ -0,0 +1,41 @@
+import { n as resolveMxllogError, r as serializeMxllogErrorResponse, t as extractErrorStatus } from "../nitro-Dsv6dSzv.mjs";
+import { getRequestURL, send, setResponseHeader, setResponseStatus } from "h3";
+import { defineNitroErrorHandler } from "nitropack/runtime/internal/error/utils";
+
+//#region src/nitro/errorHandler.ts
+/**
+* Custom Nitro error handler that properly serializes MxllogError.
+* This ensures that 'data' (containing 'why', 'fix', 'link') is preserved
+* in the JSON response regardless of the underlying HTTP framework.
+*
+* For non-MxllogError, it preserves Nitro's default response shape while
+* sanitizing internal error details in production for 5xx errors.
+*/
+var errorHandler_default = defineNitroErrorHandler((error, event) => {
+	const mxllogError = resolveMxllogError(error);
+	const isDev = process.env.NODE_ENV === "development";
+	const url = getRequestURL(event, { xForwardedHost: true }).pathname;
+	if (!mxllogError) {
+		const status = extractErrorStatus(error);
+		const rawMessage = (error.statusText ?? error.statusMessage ?? error.message) || "Internal Server Error";
+		const message = isDev ? rawMessage : status >= 500 ? "Internal Server Error" : rawMessage;
+		setResponseStatus(event, status);
+		setResponseHeader(event, "Content-Type", "application/json");
+		return send(event, JSON.stringify({
+			url,
+			status,
+			statusCode: status,
+			statusText: message,
+			statusMessage: message,
+			message,
+			error: true
+		}));
+	}
+	setResponseStatus(event, extractErrorStatus(mxllogError));
+	setResponseHeader(event, "Content-Type", "application/json");
+	return send(event, JSON.stringify(serializeMxllogErrorResponse(mxllogError, url)));
+});
+
+//#endregion
+export { errorHandler_default as default };
+//# sourceMappingURL=errorHandler.mjs.map

package/dist/nitro/errorHandler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandler.mjs","names":[],"sources":["../../src/nitro/errorHandler.ts"],"sourcesContent":["// Import from specific subpath — the barrel 'nitropack/runtime' re-exports from\n// internal/app.mjs which imports virtual modules that crash outside rollup builds.\nimport { defineNitroErrorHandler } from 'nitropack/runtime/internal/error/utils'\nimport { getRequestURL, setResponseHeader, setResponseStatus, send } from 'h3'\nimport { resolveMxllogError, extractErrorStatus, serializeMxllogErrorResponse } from '../nitro'\n\n/**\n * Custom Nitro error handler that properly serializes MxllogError.\n * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved\n * in the JSON response regardless of the underlying HTTP framework.\n *\n * For non-MxllogError, it preserves Nitro's default response shape while\n * sanitizing internal error details in production for 5xx errors.\n */\nexport default defineNitroErrorHandler((error, event) => {\n  const mxllogError = resolveMxllogError(error)\n\n  const isDev = process.env.NODE_ENV === 'development'\n  const url = getRequestURL(event, { xForwardedHost: true }).pathname\n\n  // For non-MxllogError, preserve Nitro's default response shape\n  if (!mxllogError) {\n    const status = extractErrorStatus(error)\n\n    // Derive message from statusText/statusMessage/message for cross-version compatibility\n    const rawMessage = ((error as { statusText?: string }).statusText\n      ?? (error as { statusMessage?: string }).statusMessage\n      ?? error.message) || 'Internal Server Error'\n\n    // Sanitize internal error details in production for 5xx errors\n    const message = isDev\n      ? rawMessage\n      : (status >= 500 ? 'Internal Server Error' : rawMessage)\n\n    setResponseStatus(event, status)\n    setResponseHeader(event, 'Content-Type', 'application/json')\n\n    return send(event, JSON.stringify({\n      url,\n      status,\n      statusCode: status,\n      statusText: message,\n      statusMessage: message,\n      message,\n      error: true,\n    }))\n  }\n\n  const status = extractErrorStatus(mxllogError)\n\n  setResponseStatus(event, status)\n  setResponseHeader(event, 'Content-Type', 'application/json')\n\n  return send(event, JSON.stringify(serializeMxllogErrorResponse(mxllogError, url)))\n})\n"],"mappings":";;;;;;;;;;;;;AAcA,2BAAe,yBAAyB,OAAO,UAAU;CACvD,MAAM,cAAc,mBAAmB,MAAM;CAE7C,MAAM,QAAQ,QAAQ,IAAI,aAAa;CACvC,MAAM,MAAM,cAAc,OAAO,EAAE,gBAAgB,MAAM,CAAC,CAAC;AAG3D,KAAI,CAAC,aAAa;EAChB,MAAM,SAAS,mBAAmB,MAAM;EAGxC,MAAM,cAAe,MAAkC,cACjD,MAAqC,iBACtC,MAAM,YAAY;EAGvB,MAAM,UAAU,QACZ,aACC,UAAU,MAAM,0BAA0B;AAE/C,oBAAkB,OAAO,OAAO;AAChC,oBAAkB,OAAO,gBAAgB,mBAAmB;AAE5D,SAAO,KAAK,OAAO,KAAK,UAAU;GAChC;GACA;GACA,YAAY;GACZ,YAAY;GACZ,eAAe;GACf;GACA,OAAO;GACR,CAAC,CAAC;;AAKL,mBAAkB,OAFH,mBAAmB,YAAY,CAEd;AAChC,mBAAkB,OAAO,gBAAgB,mBAAmB;AAE5D,QAAO,KAAK,OAAO,KAAK,UAAU,6BAA6B,aAAa,IAAI,CAAC,CAAC;EAClF"}