evlog 1.1.0 → 1.3.0

package/README.md

@@ -346,6 +346,49 @@ async function processSyncJob(job: Job) {
 }
 ```
 
+## Cloudflare Workers
+
+Use the Workers adapter for structured logs and correct platform severity.
+
+```typescript
+// src/index.ts
+import { initWorkersLogger, createWorkersLogger } from 'evlog/workers'
+
+initWorkersLogger({
+  env: { service: 'edge-api' },
+})
+
+export default {
+  async fetch(request: Request) {
+    const log = createWorkersLogger(request)
+
+    try {
+      log.set({ route: 'health' })
+      const response = new Response('ok', { status: 200 })
+      log.emit({ status: response.status })
+      return response
+    } catch (error) {
+      log.error(error as Error)
+      log.emit({ status: 500 })
+      throw error
+    }
+  },
+}
+```
+
+Disable invocation logs to avoid duplicate request logs:
+
+```toml
+# wrangler.toml
+[observability.logs]
+invocation_logs = false
+```
+
+Notes:
+- `requestId` defaults to `cf-ray` when available
+- `request.cf` is included (colo, country, asn) unless disabled
+- Use `headerAllowlist` to avoid logging sensitive headers
+
 ## API Reference
 
 ### `initLogger(config)`
@@ -362,6 +405,7 @@ initLogger({
     region?: string      // Deployment region
   },
   pretty?: boolean       // Pretty print (default: true in dev)
+  stringify?: boolean    // JSON.stringify output (default: true, false for Workers)
   include?: string[]     // Route patterns to log (glob), e.g. ['/api/**']
   sampling?: {
     rates?: {            // Head sampling (random per level)
@@ -479,6 +523,34 @@ log.emit()                         // Emit final event
 log.getContext()                   // Get current context
 ```
 
+### `initWorkersLogger(options?)`
+
+Initialize evlog for Cloudflare Workers (object logs + correct severity).
+
+```typescript
+import { initWorkersLogger } from 'evlog/workers'
+
+initWorkersLogger({
+  env: { service: 'edge-api' },
+})
+```
+
+### `createWorkersLogger(request, options?)`
+
+Create a request-scoped logger for Workers. Auto-extracts `cf-ray`, `request.cf`, method, and path.
+
+```typescript
+import { createWorkersLogger } from 'evlog/workers'
+
+const log = createWorkersLogger(request, {
+  requestId: 'custom-id',      // Override cf-ray (default: cf-ray header)
+  headers: ['x-request-id'],   // Headers to include (default: none)
+})
+
+log.set({ user: { id: '123' } })
+log.emit({ status: 200 })
+```
+
 ### `createError(options)`
 
 Create a structured error with HTTP status support. Import from `evlog` directly to avoid conflicts with Nuxt/Nitro's `createError`.

package/dist/adapters/axiom.d.mts

@@ -0,0 +1,62 @@
+import { DrainContext, WideEvent } from '../types.mjs';
+
+interface AxiomConfig {
+    /** Axiom dataset name */
+    dataset: string;
+    /** Axiom API token */
+    token: string;
+    /** Organization ID (required for Personal Access Tokens) */
+    orgId?: string;
+    /** Base URL for Axiom API. Default: https://api.axiom.co */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/**
+ * Create a drain function for sending logs to Axiom.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createAxiomDrain()
+ * 2. runtimeConfig.evlog.axiom
+ * 3. runtimeConfig.axiom
+ * 4. Environment variables: NUXT_AXIOM_*, AXIOM_*
+ *
+ * @example
+ * ```ts
+ * // Zero config - just set NUXT_AXIOM_TOKEN and NUXT_AXIOM_DATASET env vars
+ * nitroApp.hooks.hook('evlog:drain', createAxiomDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createAxiomDrain({
+ *   dataset: 'my-dataset',
+ * }))
+ * ```
+ */
+declare function createAxiomDrain(overrides?: Partial<AxiomConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to Axiom.
+ *
+ * @example
+ * ```ts
+ * await sendToAxiom(event, {
+ *   dataset: 'my-logs',
+ *   token: process.env.AXIOM_TOKEN!,
+ * })
+ * ```
+ */
+declare function sendToAxiom(event: WideEvent, config: AxiomConfig): Promise<void>;
+/**
+ * Send a batch of events to Axiom.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToAxiom(events, {
+ *   dataset: 'my-logs',
+ *   token: process.env.AXIOM_TOKEN!,
+ * })
+ * ```
+ */
+declare function sendBatchToAxiom(events: WideEvent[], config: AxiomConfig): Promise<void>;
+
+export { createAxiomDrain, sendBatchToAxiom, sendToAxiom };
+export type { AxiomConfig };

package/dist/adapters/axiom.d.ts

@@ -0,0 +1,62 @@
+import { DrainContext, WideEvent } from '../types.js';
+
+interface AxiomConfig {
+    /** Axiom dataset name */
+    dataset: string;
+    /** Axiom API token */
+    token: string;
+    /** Organization ID (required for Personal Access Tokens) */
+    orgId?: string;
+    /** Base URL for Axiom API. Default: https://api.axiom.co */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/**
+ * Create a drain function for sending logs to Axiom.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createAxiomDrain()
+ * 2. runtimeConfig.evlog.axiom
+ * 3. runtimeConfig.axiom
+ * 4. Environment variables: NUXT_AXIOM_*, AXIOM_*
+ *
+ * @example
+ * ```ts
+ * // Zero config - just set NUXT_AXIOM_TOKEN and NUXT_AXIOM_DATASET env vars
+ * nitroApp.hooks.hook('evlog:drain', createAxiomDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createAxiomDrain({
+ *   dataset: 'my-dataset',
+ * }))
+ * ```
+ */
+declare function createAxiomDrain(overrides?: Partial<AxiomConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to Axiom.
+ *
+ * @example
+ * ```ts
+ * await sendToAxiom(event, {
+ *   dataset: 'my-logs',
+ *   token: process.env.AXIOM_TOKEN!,
+ * })
+ * ```
+ */
+declare function sendToAxiom(event: WideEvent, config: AxiomConfig): Promise<void>;
+/**
+ * Send a batch of events to Axiom.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToAxiom(events, {
+ *   dataset: 'my-logs',
+ *   token: process.env.AXIOM_TOKEN!,
+ * })
+ * ```
+ */
+declare function sendBatchToAxiom(events: WideEvent[], config: AxiomConfig): Promise<void>;
+
+export { createAxiomDrain, sendBatchToAxiom, sendToAxiom };
+export type { AxiomConfig };

package/dist/adapters/axiom.mjs

@@ -0,0 +1,65 @@
+function getRuntimeConfig() {
+  try {
+    const { useRuntimeConfig } = require("nitropack/runtime");
+    return useRuntimeConfig();
+  } catch {
+    return void 0;
+  }
+}
+function createAxiomDrain(overrides) {
+  return async (ctx) => {
+    const runtimeConfig = getRuntimeConfig();
+    const evlogAxiom = runtimeConfig?.evlog?.axiom;
+    const rootAxiom = runtimeConfig?.axiom;
+    const config = {
+      dataset: overrides?.dataset ?? evlogAxiom?.dataset ?? rootAxiom?.dataset ?? process.env.NUXT_AXIOM_DATASET ?? process.env.AXIOM_DATASET,
+      token: overrides?.token ?? evlogAxiom?.token ?? rootAxiom?.token ?? process.env.NUXT_AXIOM_TOKEN ?? process.env.AXIOM_TOKEN,
+      orgId: overrides?.orgId ?? evlogAxiom?.orgId ?? rootAxiom?.orgId ?? process.env.NUXT_AXIOM_ORG_ID ?? process.env.AXIOM_ORG_ID,
+      baseUrl: overrides?.baseUrl ?? evlogAxiom?.baseUrl ?? rootAxiom?.baseUrl ?? process.env.NUXT_AXIOM_URL ?? process.env.AXIOM_URL,
+      timeout: overrides?.timeout ?? evlogAxiom?.timeout ?? rootAxiom?.timeout
+    };
+    if (!config.dataset || !config.token) {
+      console.error("[evlog/axiom] Missing dataset or token. Set NUXT_AXIOM_TOKEN/NUXT_AXIOM_DATASET env vars or pass to createAxiomDrain()");
+      return;
+    }
+    try {
+      await sendToAxiom(ctx.event, config);
+    } catch (error) {
+      console.error("[evlog/axiom] Failed to send event:", error);
+    }
+  };
+}
+async function sendToAxiom(event, config) {
+  await sendBatchToAxiom([event], config);
+}
+async function sendBatchToAxiom(events, config) {
+  const baseUrl = config.baseUrl ?? "https://api.axiom.co";
+  const timeout = config.timeout ?? 5e3;
+  const url = `${baseUrl}/v1/datasets/${encodeURIComponent(config.dataset)}/ingest`;
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${config.token}`
+  };
+  if (config.orgId) {
+    headers["X-Axiom-Org-Id"] = config.orgId;
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(events),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "Unknown error");
+      const safeText = text.length > 200 ? `${text.slice(0, 200)}...[truncated]` : text;
+      throw new Error(`Axiom API error: ${response.status} ${response.statusText} - ${safeText}`);
+    }
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+export { createAxiomDrain, sendBatchToAxiom, sendToAxiom };

package/dist/adapters/otlp.d.mts

@@ -0,0 +1,83 @@
+import { DrainContext, WideEvent } from '../types.mjs';
+
+interface OTLPConfig {
+    /** OTLP HTTP endpoint (e.g., http://localhost:4318) */
+    endpoint: string;
+    /** Override service name (defaults to event.service) */
+    serviceName?: string;
+    /** Additional resource attributes */
+    resourceAttributes?: Record<string, string | number | boolean>;
+    /** Custom headers (e.g., for authentication) */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/** OTLP Log Record structure */
+interface OTLPLogRecord {
+    timeUnixNano: string;
+    severityNumber: number;
+    severityText: string;
+    body: {
+        stringValue: string;
+    };
+    attributes: Array<{
+        key: string;
+        value: {
+            stringValue?: string;
+            intValue?: string;
+            boolValue?: boolean;
+        };
+    }>;
+    traceId?: string;
+    spanId?: string;
+}
+/**
+ * Convert an evlog WideEvent to an OTLP LogRecord.
+ */
+declare function toOTLPLogRecord(event: WideEvent): OTLPLogRecord;
+/**
+ * Create a drain function for sending logs to an OTLP endpoint.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createOTLPDrain()
+ * 2. runtimeConfig.evlog.otlp (NUXT_EVLOG_OTLP_*)
+ * 3. runtimeConfig.otlp (NUXT_OTLP_*)
+ * 4. Environment variables: OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_SERVICE_NAME
+ *
+ * @example
+ * ```ts
+ * // Zero config - reads from runtimeConfig or env vars
+ * nitroApp.hooks.hook('evlog:drain', createOTLPDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createOTLPDrain({
+ *   endpoint: 'http://localhost:4318',
+ * }))
+ * ```
+ */
+declare function createOTLPDrain(overrides?: Partial<OTLPConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to an OTLP endpoint.
+ *
+ * @example
+ * ```ts
+ * await sendToOTLP(event, {
+ *   endpoint: 'http://localhost:4318',
+ * })
+ * ```
+ */
+declare function sendToOTLP(event: WideEvent, config: OTLPConfig): Promise<void>;
+/**
+ * Send a batch of events to an OTLP endpoint.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToOTLP(events, {
+ *   endpoint: 'http://localhost:4318',
+ * })
+ * ```
+ */
+declare function sendBatchToOTLP(events: WideEvent[], config: OTLPConfig): Promise<void>;
+
+export { createOTLPDrain, sendBatchToOTLP, sendToOTLP, toOTLPLogRecord };
+export type { OTLPConfig, OTLPLogRecord };

package/dist/adapters/otlp.d.ts

@@ -0,0 +1,83 @@
+import { DrainContext, WideEvent } from '../types.js';
+
+interface OTLPConfig {
+    /** OTLP HTTP endpoint (e.g., http://localhost:4318) */
+    endpoint: string;
+    /** Override service name (defaults to event.service) */
+    serviceName?: string;
+    /** Additional resource attributes */
+    resourceAttributes?: Record<string, string | number | boolean>;
+    /** Custom headers (e.g., for authentication) */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/** OTLP Log Record structure */
+interface OTLPLogRecord {
+    timeUnixNano: string;
+    severityNumber: number;
+    severityText: string;
+    body: {
+        stringValue: string;
+    };
+    attributes: Array<{
+        key: string;
+        value: {
+            stringValue?: string;
+            intValue?: string;
+            boolValue?: boolean;
+        };
+    }>;
+    traceId?: string;
+    spanId?: string;
+}
+/**
+ * Convert an evlog WideEvent to an OTLP LogRecord.
+ */
+declare function toOTLPLogRecord(event: WideEvent): OTLPLogRecord;
+/**
+ * Create a drain function for sending logs to an OTLP endpoint.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createOTLPDrain()
+ * 2. runtimeConfig.evlog.otlp (NUXT_EVLOG_OTLP_*)
+ * 3. runtimeConfig.otlp (NUXT_OTLP_*)
+ * 4. Environment variables: OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_SERVICE_NAME
+ *
+ * @example
+ * ```ts
+ * // Zero config - reads from runtimeConfig or env vars
+ * nitroApp.hooks.hook('evlog:drain', createOTLPDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createOTLPDrain({
+ *   endpoint: 'http://localhost:4318',
+ * }))
+ * ```
+ */
+declare function createOTLPDrain(overrides?: Partial<OTLPConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to an OTLP endpoint.
+ *
+ * @example
+ * ```ts
+ * await sendToOTLP(event, {
+ *   endpoint: 'http://localhost:4318',
+ * })
+ * ```
+ */
+declare function sendToOTLP(event: WideEvent, config: OTLPConfig): Promise<void>;
+/**
+ * Send a batch of events to an OTLP endpoint.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToOTLP(events, {
+ *   endpoint: 'http://localhost:4318',
+ * })
+ * ```
+ */
+declare function sendBatchToOTLP(events: WideEvent[], config: OTLPConfig): Promise<void>;
+
+export { createOTLPDrain, sendBatchToOTLP, sendToOTLP, toOTLPLogRecord };
+export type { OTLPConfig, OTLPLogRecord };

package/dist/adapters/otlp.mjs

@@ -0,0 +1,202 @@
+const SEVERITY_MAP = {
+  debug: 5,
+  // DEBUG
+  info: 9,
+  // INFO
+  warn: 13,
+  // WARN
+  error: 17
+  // ERROR
+};
+const SEVERITY_TEXT_MAP = {
+  debug: "DEBUG",
+  info: "INFO",
+  warn: "WARN",
+  error: "ERROR"
+};
+function getRuntimeConfig() {
+  try {
+    const { useRuntimeConfig } = require("nitropack/runtime");
+    return useRuntimeConfig();
+  } catch {
+    return void 0;
+  }
+}
+function toAttributeValue(value) {
+  if (typeof value === "boolean") {
+    return { boolValue: value };
+  }
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return { intValue: String(value) };
+  }
+  if (typeof value === "string") {
+    return { stringValue: value };
+  }
+  return { stringValue: JSON.stringify(value) };
+}
+function toOTLPLogRecord(event) {
+  const timestamp = new Date(event.timestamp).getTime() * 1e6;
+  const { level, traceId, spanId, ...rest } = event;
+  delete rest.timestamp;
+  delete rest.service;
+  delete rest.environment;
+  delete rest.version;
+  delete rest.commitHash;
+  delete rest.region;
+  const attributes = [];
+  for (const [key, value] of Object.entries(rest)) {
+    if (value !== void 0 && value !== null) {
+      attributes.push({
+        key,
+        value: toAttributeValue(value)
+      });
+    }
+  }
+  const record = {
+    timeUnixNano: String(timestamp),
+    severityNumber: SEVERITY_MAP[level] ?? 9,
+    severityText: SEVERITY_TEXT_MAP[level] ?? "INFO",
+    body: { stringValue: JSON.stringify(event) },
+    attributes
+  };
+  if (typeof traceId === "string") {
+    record.traceId = traceId;
+  }
+  if (typeof spanId === "string") {
+    record.spanId = spanId;
+  }
+  return record;
+}
+function buildResourceAttributes(event, config) {
+  const attributes = [];
+  attributes.push({
+    key: "service.name",
+    value: { stringValue: config.serviceName ?? event.service }
+  });
+  if (event.environment) {
+    attributes.push({
+      key: "deployment.environment",
+      value: { stringValue: event.environment }
+    });
+  }
+  if (event.version) {
+    attributes.push({
+      key: "service.version",
+      value: { stringValue: event.version }
+    });
+  }
+  if (event.region) {
+    attributes.push({
+      key: "cloud.region",
+      value: { stringValue: event.region }
+    });
+  }
+  if (event.commitHash) {
+    attributes.push({
+      key: "vcs.commit.id",
+      value: { stringValue: event.commitHash }
+    });
+  }
+  if (config.resourceAttributes) {
+    for (const [key, value] of Object.entries(config.resourceAttributes)) {
+      attributes.push({
+        key,
+        value: toAttributeValue(value)
+      });
+    }
+  }
+  return attributes;
+}
+function createOTLPDrain(overrides) {
+  return async (ctx) => {
+    const runtimeConfig = getRuntimeConfig();
+    const evlogOtlp = runtimeConfig?.evlog?.otlp;
+    const rootOtlp = runtimeConfig?.otlp;
+    const getHeadersFromEnv = () => {
+      const headersEnv = process.env.OTEL_EXPORTER_OTLP_HEADERS || process.env.NUXT_OTLP_HEADERS;
+      if (headersEnv) {
+        const headers = {};
+        const decoded = decodeURIComponent(headersEnv);
+        for (const pair of decoded.split(",")) {
+          const eqIndex = pair.indexOf("=");
+          if (eqIndex > 0) {
+            const key = pair.slice(0, eqIndex).trim();
+            const value = pair.slice(eqIndex + 1).trim();
+            if (key && value) {
+              headers[key] = value;
+            }
+          }
+        }
+        if (Object.keys(headers).length > 0) return headers;
+      }
+      const auth = process.env.NUXT_OTLP_AUTH;
+      if (auth) {
+        return { Authorization: auth };
+      }
+      return void 0;
+    };
+    const config = {
+      endpoint: overrides?.endpoint ?? evlogOtlp?.endpoint ?? rootOtlp?.endpoint ?? process.env.NUXT_OTLP_ENDPOINT ?? process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+      serviceName: overrides?.serviceName ?? evlogOtlp?.serviceName ?? rootOtlp?.serviceName ?? process.env.NUXT_OTLP_SERVICE_NAME ?? process.env.OTEL_SERVICE_NAME,
+      headers: overrides?.headers ?? evlogOtlp?.headers ?? rootOtlp?.headers ?? getHeadersFromEnv(),
+      resourceAttributes: overrides?.resourceAttributes ?? evlogOtlp?.resourceAttributes ?? rootOtlp?.resourceAttributes,
+      timeout: overrides?.timeout ?? evlogOtlp?.timeout ?? rootOtlp?.timeout
+    };
+    if (!config.endpoint) {
+      console.error("[evlog/otlp] Missing endpoint. Set NUXT_OTLP_ENDPOINT or OTEL_EXPORTER_OTLP_ENDPOINT env var, or pass to createOTLPDrain()");
+      return;
+    }
+    try {
+      await sendToOTLP(ctx.event, config);
+    } catch (error) {
+      console.error("[evlog/otlp] Failed to send event:", error);
+    }
+  };
+}
+async function sendToOTLP(event, config) {
+  await sendBatchToOTLP([event], config);
+}
+async function sendBatchToOTLP(events, config) {
+  if (events.length === 0) return;
+  const timeout = config.timeout ?? 5e3;
+  const url = `${config.endpoint.replace(/\/$/, "")}/v1/logs`;
+  const [firstEvent] = events;
+  const resourceAttributes = buildResourceAttributes(firstEvent, config);
+  const logRecords = events.map(toOTLPLogRecord);
+  const payload = {
+    resourceLogs: [
+      {
+        resource: { attributes: resourceAttributes },
+        scopeLogs: [
+          {
+            scope: { name: "evlog", version: "1.0.0" },
+            logRecords
+          }
+        ]
+      }
+    ]
+  };
+  const headers = {
+    "Content-Type": "application/json",
+    ...config.headers
+  };
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "Unknown error");
+      const safeText = text.length > 200 ? `${text.slice(0, 200)}...[truncated]` : text;
+      throw new Error(`OTLP API error: ${response.status} ${response.statusText} - ${safeText}`);
+    }
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+export { createOTLPDrain, sendBatchToOTLP, sendToOTLP, toOTLPLogRecord };

package/dist/error.d.mts

@@ -16,16 +16,23 @@ import { ErrorOptions } from './types.mjs';
  * ```
  */
 declare class EvlogError extends Error {
+    /** HTTP status code */
     readonly status: number;
     readonly why?: string;
     readonly fix?: string;
     readonly link?: string;
     constructor(options: ErrorOptions | string);
+    /** HTTP status text (alias for message) */
+    get statusText(): string;
+    /** HTTP status code (alias for compatibility) */
     get statusCode(): number;
+    /** HTTP status message (alias for compatibility) */
+    get statusMessage(): string;
+    /** Structured data for serialization */
     get data(): {
-        why: string | undefined;
-        fix: string | undefined;
-        link: string | undefined;
+        why?: string;
+        fix?: string;
+        link?: string;
     } | undefined;
     toString(): string;
     toJSON(): Record<string, unknown>;
@@ -34,7 +41,7 @@ declare class EvlogError extends Error {
  * Create a structured error with context for debugging and user-facing messages.
  *
  * @param options - Error message string or full options object
- * @returns EvlogError instance compatible with Nitro's error handling
+ * @returns EvlogError with HTTP metadata (`status`, `statusText`) and `data`; also includes `statusCode` and `statusMessage` for legacy compatibility
  *
  * @example
  * ```ts
@@ -52,6 +59,5 @@ declare class EvlogError extends Error {
  * ```
  */
 declare function createError(options: ErrorOptions | string): EvlogError;
-declare const createEvlogError: typeof createError;
 
-export { EvlogError, createError, createEvlogError };
+export { EvlogError, createError, createError as createEvlogError };