TypeScript Types

All types are exported from the errorcore package and can be imported directly:

importing types

import type { SDKConfig, ErrorPackage, Completeness, ResolvedConfig } from "errorcore";
import type { SDKInstance } from "errorcore";

SDKConfig

The configuration object passed to init(). All fields are optional except transport.

interface SDKConfig {
  transport: TransportConfig;
  encryptionKey?: string;
  allowUnencrypted?: boolean;

  // capture
  captureLocalVariables?: boolean;
  captureRequestBodies?: boolean;
  captureResponseBodies?: boolean;
  captureBody?: boolean;
  captureBodyDigest?: boolean;
  captureDbBindParams?: boolean;
  bodyCaptureContentTypes?: string[];

  // filtering
  headerAllowlist?: string[];
  headerBlocklist?: RegExp[];
  envAllowlist?: string[];
  envBlocklist?: RegExp[];
  piiScrubber?: (key: string, value: unknown) => unknown;
  replaceDefaultScrubber?: boolean;

  // buffer and performance
  bufferSize?: number;
  bufferMaxBytes?: number;
  maxPayloadSize?: number;
  maxConcurrentRequests?: number;
  rateLimitPerMinute?: number;
  rateLimitWindowMs?: number;

  // local variables
  maxLocalsCollectionsPerSecond?: number;
  maxCachedLocals?: number;
  maxLocalsFrames?: number;

  // serialization
  serialization?: Partial<SerializationLimits>;

  // transport and delivery
  deadLetterPath?: string;
  maxDrainOnStartup?: number;
  flushIntervalMs?: number;
  uncaughtExceptionExitDelayMs?: number;

  // advanced
  useWorkerAssembly?: boolean;
  resolveSourceMaps?: boolean;
  allowPlainHttpTransport?: boolean;
  allowInvalidCollectorCertificates?: boolean;
}

TransportConfig

Defines where incident packages are delivered:

type TransportConfig =
  | { type: "stdout" }
  | { type: "file"; path: string; maxSizeBytes?: number; maxBackups?: number }
  | {
      type: "http";
      url: string;
      authorization?: string;
      timeoutMs?: number;
      maxBackups?: number;
    };

ErrorPackage

The full incident payload that gets serialized and delivered:

interface ErrorPackage {
  schemaVersion: "1.0.0";
  capturedAt: string;
  timeAnchor: { wallClockMs: number; hrtimeNs: string };
  error: {
    type: string;
    message: string;
    stack: string;
    rawStack?: string;
    cause?: ErrorInfo;
    properties: Record<string, unknown>;
  };
  localVariables?: CapturedFrame[];
  request?: {
    id: string;
    method: string;
    url: string;
    headers: Record<string, string>;
    body?: string | object;
    bodyTruncated?: boolean;
    receivedAt: string;
  };
  ioTimeline: IOEventSerialized[];
  evictionLog: EvictionRecordSerialized[];
  ambientContext?: AmbientEventContext;
  stateReads: StateReadSerialized[];
  concurrentRequests: RequestSummary[];
  processMetadata: ProcessMetadata;
  codeVersion: { gitSha?: string; packageVersion?: string };
  environment: Record<string, string>;
  integrity?: { algorithm: "HMAC-SHA256"; signature: string };
  completeness: Completeness;
}

Completeness

Reports what was and was not captured for a given incident:

interface Completeness {
  requestCaptured: boolean;
  requestBodyTruncated: boolean;
  ioTimelineCaptured: boolean;
  usedAmbientEvents: boolean;
  ioEventsDropped: number;
  ioPayloadsTruncated: number;
  alsContextAvailable: boolean;
  localVariablesCaptured: boolean;
  localVariablesTruncated: boolean;
  stateTrackingEnabled: boolean;
  stateReadsCaptured: boolean;
  concurrentRequestsCaptured: boolean;
  piiScrubbed: boolean;
  encrypted: boolean;
  captureFailures: string[];
  rateLimiterDrops?: {
    droppedCount: number;
    firstDropMs: number;
    lastDropMs: number;
  };
}

SerializationLimits

Controls how deeply and widely values are cloned into the incident package:

interface SerializationLimits {
  maxDepth: number;           // default: 8
  maxArrayItems: number;      // default: 20
  maxObjectKeys: number;      // default: 50
  maxStringLength: number;    // default: 2048
  maxPayloadSize: number;     // default: 32768 (32 KB)
  maxTotalPackageSize: number; // default: 5242880 (5 MB)
}

CapturedFrame

A single stack frame with captured local variables:

interface CapturedFrame {
  functionName: string;
  filePath: string;
  lineNumber: number;
  columnNumber: number;
  locals: Record<string, unknown>;
}

ProcessMetadata

Runtime information about the Node.js process at the time of capture:

interface ProcessMetadata {
  nodeVersion: string;
  v8Version: string;
  platform: string;
  arch: string;
  pid: number;
  hostname: string;
  containerId?: string;
  uptime: number;
  memoryUsage: {
    rss: number;
    heapTotal: number;
    heapUsed: number;
    external: number;
    arrayBuffers: number;
  };
  activeHandles: number;
  activeRequests: number;
  activeResourceTypes?: Record<string, number>;
  eventLoopLagMs: number;
}

On this page