stream-guard 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,270 @@
+import { Readable, Writable, Duplex, Transform } from 'node:stream';
+import { EventEmitter } from 'node:events';
+
+/**
+ * Base error class for all stream-guard errors.
+ * Provides consistent error structure and metadata.
+ */
+declare abstract class StreamGuardError extends Error {
+    /** Timestamp when the error occurred */
+    readonly timestamp: number;
+    /** The constraint that was violated */
+    abstract readonly constraint: string;
+    constructor(message: string);
+}
+/**
+ * Thrown when a stream exceeds the absolute timeout limit.
+ *
+ * @example
+ * ```ts
+ * stream.on('error', (err) => {
+ *   if (err instanceof StreamTimeoutError) {
+ *     console.log(`Stream timed out after ${err.timeoutMs}ms`);
+ *   }
+ * });
+ * ```
+ */
+declare class StreamTimeoutError extends StreamGuardError {
+    readonly constraint = "timeout";
+    /** The timeout limit that was exceeded (in milliseconds) */
+    readonly timeoutMs: number;
+    /** Actual elapsed time when the timeout was triggered */
+    readonly elapsedMs: number;
+    constructor(timeoutMs: number, elapsedMs: number);
+}
+/**
+ * Thrown when a stream stalls (no data flow) for too long.
+ * This typically indicates a zombie connection or slow loris attack.
+ *
+ * @example
+ * ```ts
+ * stream.on('error', (err) => {
+ *   if (err instanceof StreamStalledError) {
+ *     console.log(`Stream stalled for ${err.stalledMs}ms`);
+ *   }
+ * });
+ * ```
+ */
+declare class StreamStalledError extends StreamGuardError {
+    readonly constraint = "stalled";
+    /** The stall threshold that was exceeded (in milliseconds) */
+    readonly stalledMs: number;
+    /** Time since last data activity */
+    readonly idleMs: number;
+    constructor(stalledMs: number, idleMs: number);
+}
+/**
+ * Thrown when a stream exceeds the maximum allowed bytes.
+ *
+ * @example
+ * ```ts
+ * stream.on('error', (err) => {
+ *   if (err instanceof StreamLimitError) {
+ *     console.log(`Stream exceeded ${err.maxBytes} bytes`);
+ *   }
+ * });
+ * ```
+ */
+declare class StreamLimitError extends StreamGuardError {
+    readonly constraint = "maxBytes";
+    /** The maximum bytes limit that was exceeded */
+    readonly maxBytes: number;
+    /** The actual number of bytes transferred */
+    readonly bytesTransferred: number;
+    constructor(maxBytes: number, bytesTransferred: number);
+}
+/**
+ * Thrown when the process heap usage exceeds the configured limit during stream processing.
+ * This is a safety mechanism to prevent OOM crashes.
+ *
+ * @example
+ * ```ts
+ * stream.on('error', (err) => {
+ *   if (err instanceof StreamHeapError) {
+ *     console.log(`Heap exceeded: ${err.heapUsed} / ${err.maxHeap}`);
+ *   }
+ * });
+ * ```
+ */
+declare class StreamHeapError extends StreamGuardError {
+    readonly constraint = "maxHeap";
+    /** The maximum heap limit that was exceeded (in bytes) */
+    readonly maxHeap: number;
+    /** The actual heap usage when the limit was exceeded (in bytes) */
+    readonly heapUsed: number;
+    constructor(maxHeap: number, heapUsed: number);
+}
+/**
+ * Type guard to check if an error is a StreamGuardError.
+ */
+declare function isStreamGuardError(error: unknown): error is StreamGuardError;
+/**
+ * Type guard to check if an error is a StreamTimeoutError.
+ */
+declare function isStreamTimeoutError(error: unknown): error is StreamTimeoutError;
+/**
+ * Type guard to check if an error is a StreamStalledError.
+ */
+declare function isStreamStalledError(error: unknown): error is StreamStalledError;
+/**
+ * Type guard to check if an error is a StreamLimitError.
+ */
+declare function isStreamLimitError(error: unknown): error is StreamLimitError;
+/**
+ * Type guard to check if an error is a StreamHeapError.
+ */
+declare function isStreamHeapError(error: unknown): error is StreamHeapError;
+
+/**
+ * Supported stream types that can be guarded.
+ */
+type GuardableStream = (Readable | Writable | Duplex | Transform) & EventEmitter;
+/**
+ * Configuration options for the stream guard.
+ */
+interface GuardOptions {
+    /**
+     * Absolute timeout in milliseconds.
+     * If the stream doesn't complete within this time, it will be destroyed.
+     *
+     * @example
+     * ```ts
+     * guard(stream, { timeout: 30000 }); // 30 second timeout
+     * ```
+     */
+    timeout?: number;
+    /**
+     * Stall protection timeout in milliseconds.
+     * If no data flows for this duration, the stream will be destroyed.
+     * Useful for detecting zombie connections and slow loris attacks.
+     *
+     * @example
+     * ```ts
+     * guard(stream, { stalled: 5000 }); // Kill if no data for 5 seconds
+     * ```
+     */
+    stalled?: number;
+    /**
+     * Maximum bytes allowed through the stream.
+     * If exceeded, the stream will be destroyed.
+     *
+     * @example
+     * ```ts
+     * guard(stream, { maxBytes: 10 * 1024 * 1024 }); // 10MB limit
+     * ```
+     */
+    maxBytes?: number;
+    /**
+     * Maximum heap memory usage in bytes.
+     * If process.memoryUsage().heapUsed exceeds this during stream processing,
+     * the stream will be destroyed to prevent OOM crashes.
+     *
+     * @example
+     * ```ts
+     * guard(stream, { maxHeap: 500 * 1024 * 1024 }); // 500MB heap limit
+     * ```
+     */
+    maxHeap?: number;
+    /**
+     * Interval in milliseconds for heap memory checks.
+     * Lower values provide faster detection but use more CPU.
+     *
+     * @default 100
+     */
+    heapCheckInterval?: number;
+    /**
+     * Number of chunks between heap checks.
+     * Alternative to time-based heap checking.
+     * If both are set, checks happen on whichever triggers first.
+     *
+     * @default undefined (time-based only)
+     */
+    heapCheckChunks?: number;
+    /**
+     * Called when the stream is destroyed by the guard.
+     * Useful for logging and monitoring.
+     */
+    onDestroy?: (error: Error) => void;
+}
+/**
+ * Metadata attached to guarded streams.
+ */
+interface GuardMetadata {
+    /** Unique guard instance ID */
+    readonly guardId: string;
+    /** When the guard was attached */
+    readonly startTime: number;
+    /** Get current bytes transferred */
+    getBytesTransferred(): number;
+    /** Get elapsed time in milliseconds */
+    getElapsedTime(): number;
+    /** Check if guard is still active */
+    isActive(): boolean;
+    /** Manually release all guards and timers */
+    release(): void;
+}
+/**
+ * Check if a stream has already been guarded.
+ */
+declare function isGuarded(stream: GuardableStream): boolean;
+/**
+ * Get the guard metadata from a guarded stream.
+ * Returns undefined if the stream is not guarded.
+ */
+declare function getGuardMetadata(stream: GuardableStream): GuardMetadata | undefined;
+/**
+ * Guards a Node.js stream with safety constraints.
+ *
+ * Wraps any Readable, Writable, Duplex, or Transform stream and enforces:
+ * - Absolute timeout (total time to complete)
+ * - Stall detection (idle time without data flow)
+ * - Byte limits (maximum data throughput)
+ * - Heap memory limits (prevent OOM)
+ *
+ * @param stream - The stream to guard
+ * @param options - Guard configuration options
+ * @returns The same stream with guards attached
+ *
+ * @example
+ * ```ts
+ * import { guard, StreamTimeoutError } from 'stream-guard';
+ * import { createReadStream } from 'node:fs';
+ *
+ * const stream = guard(createReadStream('file.txt'), {
+ *   timeout: 30000,      // 30s absolute timeout
+ *   stalled: 5000,       // 5s stall detection
+ *   maxBytes: 10 * 1024 * 1024, // 10MB limit
+ * });
+ *
+ * stream.on('error', (err) => {
+ *   if (err instanceof StreamTimeoutError) {
+ *     console.log('Stream timed out!');
+ *   }
+ * });
+ *
+ * stream.pipe(destination);
+ * ```
+ */
+declare function guard<T extends GuardableStream>(stream: T, options?: GuardOptions): T;
+/**
+ * Creates a pre-configured guard factory with default options.
+ * Useful for applying consistent settings across multiple streams.
+ *
+ * @param defaultOptions - Default options for all guards created by this factory
+ * @returns A guard function with defaults pre-applied
+ *
+ * @example
+ * ```ts
+ * const apiGuard = createGuard({
+ *   timeout: 30000,
+ *   maxBytes: 5 * 1024 * 1024,
+ * });
+ *
+ * // All streams will have these defaults
+ * apiGuard(stream1);
+ * apiGuard(stream2, { stalled: 5000 }); // Can override
+ * ```
+ */
+declare function createGuard(defaultOptions: GuardOptions): <T extends GuardableStream>(stream: T, options?: GuardOptions) => T;
+
+export { type GuardMetadata, type GuardOptions, type GuardableStream, StreamGuardError, StreamHeapError, StreamLimitError, StreamStalledError, StreamTimeoutError, createGuard, guard as default, getGuardMetadata, guard, isGuarded, isStreamGuardError, isStreamHeapError, isStreamLimitError, isStreamStalledError, isStreamTimeoutError };

package/dist/index.js

@@ -0,0 +1,316 @@
+// src/errors.ts
+var StreamGuardError = class extends Error {
+  /** Timestamp when the error occurred */
+  timestamp;
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    this.timestamp = Date.now();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var StreamTimeoutError = class extends StreamGuardError {
+  constraint = "timeout";
+  /** The timeout limit that was exceeded (in milliseconds) */
+  timeoutMs;
+  /** Actual elapsed time when the timeout was triggered */
+  elapsedMs;
+  constructor(timeoutMs, elapsedMs) {
+    super(`Stream exceeded absolute timeout of ${timeoutMs}ms (elapsed: ${elapsedMs}ms)`);
+    this.timeoutMs = timeoutMs;
+    this.elapsedMs = elapsedMs;
+  }
+};
+var StreamStalledError = class extends StreamGuardError {
+  constraint = "stalled";
+  /** The stall threshold that was exceeded (in milliseconds) */
+  stalledMs;
+  /** Time since last data activity */
+  idleMs;
+  constructor(stalledMs, idleMs) {
+    super(`Stream stalled: no data flow for ${idleMs}ms (limit: ${stalledMs}ms)`);
+    this.stalledMs = stalledMs;
+    this.idleMs = idleMs;
+  }
+};
+var StreamLimitError = class extends StreamGuardError {
+  constraint = "maxBytes";
+  /** The maximum bytes limit that was exceeded */
+  maxBytes;
+  /** The actual number of bytes transferred */
+  bytesTransferred;
+  constructor(maxBytes, bytesTransferred) {
+    super(`Stream exceeded byte limit: ${bytesTransferred} bytes transferred (limit: ${maxBytes} bytes)`);
+    this.maxBytes = maxBytes;
+    this.bytesTransferred = bytesTransferred;
+  }
+};
+var StreamHeapError = class extends StreamGuardError {
+  constraint = "maxHeap";
+  /** The maximum heap limit that was exceeded (in bytes) */
+  maxHeap;
+  /** The actual heap usage when the limit was exceeded (in bytes) */
+  heapUsed;
+  constructor(maxHeap, heapUsed) {
+    super(`Process heap exceeded limit during stream: ${formatBytes(heapUsed)} used (limit: ${formatBytes(maxHeap)})`);
+    this.maxHeap = maxHeap;
+    this.heapUsed = heapUsed;
+  }
+};
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+}
+function isStreamGuardError(error) {
+  return error instanceof StreamGuardError;
+}
+function isStreamTimeoutError(error) {
+  return error instanceof StreamTimeoutError;
+}
+function isStreamStalledError(error) {
+  return error instanceof StreamStalledError;
+}
+function isStreamLimitError(error) {
+  return error instanceof StreamLimitError;
+}
+function isStreamHeapError(error) {
+  return error instanceof StreamHeapError;
+}
+
+// src/index.ts
+var GUARD_METADATA = /* @__PURE__ */ Symbol("stream-guard:metadata");
+function isGuarded(stream) {
+  return GUARD_METADATA in stream;
+}
+function getGuardMetadata(stream) {
+  return stream[GUARD_METADATA];
+}
+function generateGuardId() {
+  return `guard_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function getChunkSize(chunk) {
+  if (Buffer.isBuffer(chunk)) {
+    return chunk.length;
+  }
+  if (typeof chunk === "string") {
+    return Buffer.byteLength(chunk);
+  }
+  if (chunk instanceof Uint8Array) {
+    return chunk.byteLength;
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    return chunk.byteLength;
+  }
+  if (chunk !== null && typeof chunk === "object") {
+    try {
+      return Buffer.byteLength(JSON.stringify(chunk));
+    } catch {
+      return 0;
+    }
+  }
+  return 0;
+}
+function safeDestroy(stream, error) {
+  const s = stream;
+  try {
+    if (typeof s.destroy === "function") {
+      s.destroy(error);
+    } else if (typeof s.end === "function") {
+      s.end();
+      s.emit("error", error);
+    } else {
+      s.emit("error", error);
+    }
+  } catch {
+  }
+}
+function guard(stream, options = {}) {
+  if (options.timeout !== void 0 && (options.timeout <= 0 || !Number.isFinite(options.timeout))) {
+    throw new TypeError("timeout must be a positive finite number");
+  }
+  if (options.stalled !== void 0 && (options.stalled <= 0 || !Number.isFinite(options.stalled))) {
+    throw new TypeError("stalled must be a positive finite number");
+  }
+  if (options.maxBytes !== void 0 && (options.maxBytes <= 0 || !Number.isFinite(options.maxBytes))) {
+    throw new TypeError("maxBytes must be a positive finite number");
+  }
+  if (options.maxHeap !== void 0 && (options.maxHeap <= 0 || !Number.isFinite(options.maxHeap))) {
+    throw new TypeError("maxHeap must be a positive finite number");
+  }
+  if (isGuarded(stream)) {
+    throw new Error("Stream is already guarded. Call release() first to re-guard.");
+  }
+  const {
+    timeout,
+    stalled,
+    maxBytes,
+    maxHeap,
+    heapCheckInterval = 100,
+    heapCheckChunks,
+    onDestroy
+  } = options;
+  const guardId = generateGuardId();
+  const state = {
+    startTime: Date.now(),
+    lastActivityTime: Date.now(),
+    bytesTransferred: 0,
+    chunksSinceHeapCheck: 0,
+    isDestroyed: false,
+    isCompleted: false
+  };
+  const timers = {
+    absoluteTimeout: null,
+    stallInterval: null,
+    heapInterval: null
+  };
+  function cleanup() {
+    if (timers.absoluteTimeout) {
+      clearTimeout(timers.absoluteTimeout);
+      timers.absoluteTimeout = null;
+    }
+    if (timers.stallInterval) {
+      clearInterval(timers.stallInterval);
+      timers.stallInterval = null;
+    }
+    if (timers.heapInterval) {
+      clearInterval(timers.heapInterval);
+      timers.heapInterval = null;
+    }
+  }
+  function destroyWithError(error) {
+    if (state.isDestroyed || state.isCompleted) {
+      return;
+    }
+    state.isDestroyed = true;
+    cleanup();
+    if (onDestroy) {
+      try {
+        onDestroy(error);
+      } catch {
+      }
+    }
+    safeDestroy(stream, error);
+  }
+  function recordActivity() {
+    state.lastActivityTime = Date.now();
+  }
+  function processChunk(chunk) {
+    if (state.isDestroyed || state.isCompleted) {
+      return;
+    }
+    recordActivity();
+    const chunkSize = getChunkSize(chunk);
+    state.bytesTransferred += chunkSize;
+    if (maxBytes !== void 0 && state.bytesTransferred > maxBytes) {
+      destroyWithError(new StreamLimitError(maxBytes, state.bytesTransferred));
+      return;
+    }
+    if (maxHeap !== void 0 && heapCheckChunks !== void 0) {
+      state.chunksSinceHeapCheck++;
+      if (state.chunksSinceHeapCheck >= heapCheckChunks) {
+        state.chunksSinceHeapCheck = 0;
+        checkHeap();
+      }
+    }
+  }
+  function checkHeap() {
+    if (maxHeap === void 0 || state.isDestroyed || state.isCompleted) {
+      return;
+    }
+    const heapUsed = process.memoryUsage().heapUsed;
+    if (heapUsed > maxHeap) {
+      destroyWithError(new StreamHeapError(maxHeap, heapUsed));
+    }
+  }
+  function handleComplete() {
+    if (state.isCompleted) {
+      return;
+    }
+    state.isCompleted = true;
+    cleanup();
+  }
+  if (timeout !== void 0) {
+    timers.absoluteTimeout = setTimeout(() => {
+      const elapsed = Date.now() - state.startTime;
+      destroyWithError(new StreamTimeoutError(timeout, elapsed));
+    }, timeout);
+    if (timers.absoluteTimeout.unref) {
+      timers.absoluteTimeout.unref();
+    }
+  }
+  if (stalled !== void 0) {
+    timers.stallInterval = setInterval(() => {
+      if (state.isDestroyed || state.isCompleted) {
+        return;
+      }
+      const idleTime = Date.now() - state.lastActivityTime;
+      if (idleTime >= stalled) {
+        destroyWithError(new StreamStalledError(stalled, idleTime));
+      }
+    }, Math.min(stalled / 2, 1e3));
+    if (timers.stallInterval.unref) {
+      timers.stallInterval.unref();
+    }
+  }
+  if (maxHeap !== void 0) {
+    timers.heapInterval = setInterval(() => {
+      checkHeap();
+    }, heapCheckInterval);
+    if (timers.heapInterval.unref) {
+      timers.heapInterval.unref();
+    }
+  }
+  const emitter = stream;
+  emitter.on("data", processChunk);
+  emitter.on("drain", recordActivity);
+  emitter.on("end", handleComplete);
+  emitter.on("finish", handleComplete);
+  emitter.on("close", handleComplete);
+  emitter.on("error", handleComplete);
+  const metadata = {
+    guardId,
+    startTime: state.startTime,
+    getBytesTransferred: () => state.bytesTransferred,
+    getElapsedTime: () => Date.now() - state.startTime,
+    isActive: () => !state.isDestroyed && !state.isCompleted,
+    release: () => {
+      cleanup();
+      delete stream[GUARD_METADATA];
+    }
+  };
+  Object.defineProperty(stream, GUARD_METADATA, {
+    value: metadata,
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+  return stream;
+}
+function createGuard(defaultOptions) {
+  return (stream, options = {}) => {
+    return guard(stream, { ...defaultOptions, ...options });
+  };
+}
+var index_default = guard;
+export {
+  StreamGuardError,
+  StreamHeapError,
+  StreamLimitError,
+  StreamStalledError,
+  StreamTimeoutError,
+  createGuard,
+  index_default as default,
+  getGuardMetadata,
+  guard,
+  isGuarded,
+  isStreamGuardError,
+  isStreamHeapError,
+  isStreamLimitError,
+  isStreamStalledError,
+  isStreamTimeoutError
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/index.ts"],"sourcesContent":["/**\r\n * Base error class for all stream-guard errors.\r\n * Provides consistent error structure and metadata.\r\n */\r\nexport abstract class StreamGuardError extends Error {\r\n  /** Timestamp when the error occurred */\r\n  public readonly timestamp: number;\r\n  \r\n  /** The constraint that was violated */\r\n  public abstract readonly constraint: string;\r\n\r\n  constructor(message: string) {\r\n    super(message);\r\n    this.name = this.constructor.name;\r\n    this.timestamp = Date.now();\r\n    \r\n    // Maintains proper stack trace for where error was thrown (V8 engines)\r\n    if (Error.captureStackTrace) {\r\n      Error.captureStackTrace(this, this.constructor);\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Thrown when a stream exceeds the absolute timeout limit.\r\n * \r\n * @example\r\n * ```ts\r\n * stream.on('error', (err) => {\r\n *   if (err instanceof StreamTimeoutError) {\r\n *     console.log(`Stream timed out after ${err.timeoutMs}ms`);\r\n *   }\r\n * });\r\n * ```\r\n */\r\nexport class StreamTimeoutError extends StreamGuardError {\r\n  public readonly constraint = 'timeout';\r\n  \r\n  /** The timeout limit that was exceeded (in milliseconds) */\r\n  public readonly timeoutMs: number;\r\n  \r\n  /** Actual elapsed time when the timeout was triggered */\r\n  public readonly elapsedMs: number;\r\n\r\n  constructor(timeoutMs: number, elapsedMs: number) {\r\n    super(`Stream exceeded absolute timeout of ${timeoutMs}ms (elapsed: ${elapsedMs}ms)`);\r\n    this.timeoutMs = timeoutMs;\r\n    this.elapsedMs = elapsedMs;\r\n  }\r\n}\r\n\r\n/**\r\n * Thrown when a stream stalls (no data flow) for too long.\r\n * This typically indicates a zombie connection or slow loris attack.\r\n * \r\n * @example\r\n * ```ts\r\n * stream.on('error', (err) => {\r\n *   if (err instanceof StreamStalledError) {\r\n *     console.log(`Stream stalled for ${err.stalledMs}ms`);\r\n *   }\r\n * });\r\n * ```\r\n */\r\nexport class StreamStalledError extends StreamGuardError {\r\n  public readonly constraint = 'stalled';\r\n  \r\n  /** The stall threshold that was exceeded (in milliseconds) */\r\n  public readonly stalledMs: number;\r\n  \r\n  /** Time since last data activity */\r\n  public readonly idleMs: number;\r\n\r\n  constructor(stalledMs: number, idleMs: number) {\r\n    super(`Stream stalled: no data flow for ${idleMs}ms (limit: ${stalledMs}ms)`);\r\n    this.stalledMs = stalledMs;\r\n    this.idleMs = idleMs;\r\n  }\r\n}\r\n\r\n/**\r\n * Thrown when a stream exceeds the maximum allowed bytes.\r\n * \r\n * @example\r\n * ```ts\r\n * stream.on('error', (err) => {\r\n *   if (err instanceof StreamLimitError) {\r\n *     console.log(`Stream exceeded ${err.maxBytes} bytes`);\r\n *   }\r\n * });\r\n * ```\r\n */\r\nexport class StreamLimitError extends StreamGuardError {\r\n  public readonly constraint = 'maxBytes';\r\n  \r\n  /** The maximum bytes limit that was exceeded */\r\n  public readonly maxBytes: number;\r\n  \r\n  /** The actual number of bytes transferred */\r\n  public readonly bytesTransferred: number;\r\n\r\n  constructor(maxBytes: number, bytesTransferred: number) {\r\n    super(`Stream exceeded byte limit: ${bytesTransferred} bytes transferred (limit: ${maxBytes} bytes)`);\r\n    this.maxBytes = maxBytes;\r\n    this.bytesTransferred = bytesTransferred;\r\n  }\r\n}\r\n\r\n/**\r\n * Thrown when the process heap usage exceeds the configured limit during stream processing.\r\n * This is a safety mechanism to prevent OOM crashes.\r\n * \r\n * @example\r\n * ```ts\r\n * stream.on('error', (err) => {\r\n *   if (err instanceof StreamHeapError) {\r\n *     console.log(`Heap exceeded: ${err.heapUsed} / ${err.maxHeap}`);\r\n *   }\r\n * });\r\n * ```\r\n */\r\nexport class StreamHeapError extends StreamGuardError {\r\n  public readonly constraint = 'maxHeap';\r\n  \r\n  /** The maximum heap limit that was exceeded (in bytes) */\r\n  public readonly maxHeap: number;\r\n  \r\n  /** The actual heap usage when the limit was exceeded (in bytes) */\r\n  public readonly heapUsed: number;\r\n\r\n  constructor(maxHeap: number, heapUsed: number) {\r\n    super(`Process heap exceeded limit during stream: ${formatBytes(heapUsed)} used (limit: ${formatBytes(maxHeap)})`);\r\n    this.maxHeap = maxHeap;\r\n    this.heapUsed = heapUsed;\r\n  }\r\n}\r\n\r\n/**\r\n * Utility function to format bytes into human-readable string.\r\n */\r\nfunction formatBytes(bytes: number): string {\r\n  if (bytes < 1024) return `${bytes}B`;\r\n  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;\r\n  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;\r\n  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;\r\n}\r\n\r\n/**\r\n * Type guard to check if an error is a StreamGuardError.\r\n */\r\nexport function isStreamGuardError(error: unknown): error is StreamGuardError {\r\n  return error instanceof StreamGuardError;\r\n}\r\n\r\n/**\r\n * Type guard to check if an error is a StreamTimeoutError.\r\n */\r\nexport function isStreamTimeoutError(error: unknown): error is StreamTimeoutError {\r\n  return error instanceof StreamTimeoutError;\r\n}\r\n\r\n/**\r\n * Type guard to check if an error is a StreamStalledError.\r\n */\r\nexport function isStreamStalledError(error: unknown): error is StreamStalledError {\r\n  return error instanceof StreamStalledError;\r\n}\r\n\r\n/**\r\n * Type guard to check if an error is a StreamLimitError.\r\n */\r\nexport function isStreamLimitError(error: unknown): error is StreamLimitError {\r\n  return error instanceof StreamLimitError;\r\n}\r\n\r\n/**\r\n * Type guard to check if an error is a StreamHeapError.\r\n */\r\nexport function isStreamHeapError(error: unknown): error is StreamHeapError {\r\n  return error instanceof StreamHeapError;\r\n}\r\n","import type { Readable, Writable, Duplex, Transform } from 'node:stream';\r\nimport type { EventEmitter } from 'node:events';\r\n\r\nimport {\r\n  StreamTimeoutError,\r\n  StreamStalledError,\r\n  StreamLimitError,\r\n  StreamHeapError,\r\n} from './errors.js';\r\n\r\n// Re-export all error classes and type guards\r\nexport {\r\n  StreamGuardError,\r\n  StreamTimeoutError,\r\n  StreamStalledError,\r\n  StreamLimitError,\r\n  StreamHeapError,\r\n  isStreamGuardError,\r\n  isStreamTimeoutError,\r\n  isStreamStalledError,\r\n  isStreamLimitError,\r\n  isStreamHeapError,\r\n} from './errors.js';\r\n\r\n/**\r\n * Supported stream types that can be guarded.\r\n */\r\nexport type GuardableStream = (Readable | Writable | Duplex | Transform) & EventEmitter;\r\n\r\n/**\r\n * Internal interface for stream-like objects with destroy capability.\r\n */\r\ninterface DestroyableStream {\r\n  destroy?(error?: Error): void;\r\n  end?(): void;\r\n  emit(event: string | symbol, ...args: unknown[]): boolean;\r\n  on(event: string | symbol, listener: (...args: unknown[]) => void): unknown;\r\n}\r\n\r\n/**\r\n * Configuration options for the stream guard.\r\n */\r\nexport interface GuardOptions {\r\n  /**\r\n   * Absolute timeout in milliseconds.\r\n   * If the stream doesn't complete within this time, it will be destroyed.\r\n   * \r\n   * @example\r\n   * ```ts\r\n   * guard(stream, { timeout: 30000 }); // 30 second timeout\r\n   * ```\r\n   */\r\n  timeout?: number;\r\n\r\n  /**\r\n   * Stall protection timeout in milliseconds.\r\n   * If no data flows for this duration, the stream will be destroyed.\r\n   * Useful for detecting zombie connections and slow loris attacks.\r\n   * \r\n   * @example\r\n   * ```ts\r\n   * guard(stream, { stalled: 5000 }); // Kill if no data for 5 seconds\r\n   * ```\r\n   */\r\n  stalled?: number;\r\n\r\n  /**\r\n   * Maximum bytes allowed through the stream.\r\n   * If exceeded, the stream will be destroyed.\r\n   * \r\n   * @example\r\n   * ```ts\r\n   * guard(stream, { maxBytes: 10 * 1024 * 1024 }); // 10MB limit\r\n   * ```\r\n   */\r\n  maxBytes?: number;\r\n\r\n  /**\r\n   * Maximum heap memory usage in bytes.\r\n   * If process.memoryUsage().heapUsed exceeds this during stream processing,\r\n   * the stream will be destroyed to prevent OOM crashes.\r\n   * \r\n   * @example\r\n   * ```ts\r\n   * guard(stream, { maxHeap: 500 * 1024 * 1024 }); // 500MB heap limit\r\n   * ```\r\n   */\r\n  maxHeap?: number;\r\n\r\n  /**\r\n   * Interval in milliseconds for heap memory checks.\r\n   * Lower values provide faster detection but use more CPU.\r\n   * \r\n   * @default 100\r\n   */\r\n  heapCheckInterval?: number;\r\n\r\n  /**\r\n   * Number of chunks between heap checks.\r\n   * Alternative to time-based heap checking.\r\n   * If both are set, checks happen on whichever triggers first.\r\n   * \r\n   * @default undefined (time-based only)\r\n   */\r\n  heapCheckChunks?: number;\r\n\r\n  /**\r\n   * Called when the stream is destroyed by the guard.\r\n   * Useful for logging and monitoring.\r\n   */\r\n  onDestroy?: (error: Error) => void;\r\n}\r\n\r\n/**\r\n * Internal state for tracking stream metrics.\r\n */\r\ninterface GuardState {\r\n  startTime: number;\r\n  lastActivityTime: number;\r\n  bytesTransferred: number;\r\n  chunksSinceHeapCheck: number;\r\n  isDestroyed: boolean;\r\n  isCompleted: boolean;\r\n}\r\n\r\n/**\r\n * Internal timers and cleanup references.\r\n */\r\ninterface GuardTimers {\r\n  absoluteTimeout: ReturnType<typeof setTimeout> | null;\r\n  stallInterval: ReturnType<typeof setInterval> | null;\r\n  heapInterval: ReturnType<typeof setInterval> | null;\r\n}\r\n\r\n/**\r\n * Metadata attached to guarded streams.\r\n */\r\nexport interface GuardMetadata {\r\n  /** Unique guard instance ID */\r\n  readonly guardId: string;\r\n  /** When the guard was attached */\r\n  readonly startTime: number;\r\n  /** Get current bytes transferred */\r\n  getBytesTransferred(): number;\r\n  /** Get elapsed time in milliseconds */\r\n  getElapsedTime(): number;\r\n  /** Check if guard is still active */\r\n  isActive(): boolean;\r\n  /** Manually release all guards and timers */\r\n  release(): void;\r\n}\r\n\r\n// Symbol for attaching metadata without polluting the stream interface\r\nconst GUARD_METADATA = Symbol('stream-guard:metadata');\r\n\r\n/**\r\n * Helper type for streams with symbol properties\r\n */\r\ntype StreamWithMetadata = GuardableStream & { [key: symbol]: unknown };\r\n\r\n/**\r\n * Check if a stream has already been guarded.\r\n */\r\nexport function isGuarded(stream: GuardableStream): boolean {\r\n  return GUARD_METADATA in stream;\r\n}\r\n\r\n/**\r\n * Get the guard metadata from a guarded stream.\r\n * Returns undefined if the stream is not guarded.\r\n */\r\nexport function getGuardMetadata(stream: GuardableStream): GuardMetadata | undefined {\r\n  return (stream as unknown as StreamWithMetadata)[GUARD_METADATA] as GuardMetadata | undefined;\r\n}\r\n\r\n/**\r\n * Generate a unique guard ID.\r\n */\r\nfunction generateGuardId(): string {\r\n  return `guard_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;\r\n}\r\n\r\n/**\r\n * Get the byte length of a chunk.\r\n */\r\nfunction getChunkSize(chunk: unknown): number {\r\n  if (Buffer.isBuffer(chunk)) {\r\n    return chunk.length;\r\n  }\r\n  if (typeof chunk === 'string') {\r\n    return Buffer.byteLength(chunk);\r\n  }\r\n  if (chunk instanceof Uint8Array) {\r\n    return chunk.byteLength;\r\n  }\r\n  if (ArrayBuffer.isView(chunk)) {\r\n    return chunk.byteLength;\r\n  }\r\n  // For object mode streams, estimate size via JSON (rough estimate)\r\n  if (chunk !== null && typeof chunk === 'object') {\r\n    try {\r\n      return Buffer.byteLength(JSON.stringify(chunk));\r\n    } catch {\r\n      return 0;\r\n    }\r\n  }\r\n  return 0;\r\n}\r\n\r\n/**\r\n * Safely destroy a stream with an error.\r\n */\r\nfunction safeDestroy(stream: GuardableStream, error: Error): void {\r\n  const s = stream as DestroyableStream;\r\n  try {\r\n    if (typeof s.destroy === 'function') {\r\n      s.destroy(error);\r\n    } else if (typeof s.end === 'function') {\r\n      // Fallback for streams without destroy\r\n      s.end();\r\n      s.emit('error', error);\r\n    } else {\r\n      s.emit('error', error);\r\n    }\r\n  } catch {\r\n    // Stream may already be destroyed, ignore errors\r\n  }\r\n}\r\n\r\n/**\r\n * Guards a Node.js stream with safety constraints.\r\n * \r\n * Wraps any Readable, Writable, Duplex, or Transform stream and enforces:\r\n * - Absolute timeout (total time to complete)\r\n * - Stall detection (idle time without data flow)\r\n * - Byte limits (maximum data throughput)\r\n * - Heap memory limits (prevent OOM)\r\n * \r\n * @param stream - The stream to guard\r\n * @param options - Guard configuration options\r\n * @returns The same stream with guards attached\r\n * \r\n * @example\r\n * ```ts\r\n * import { guard, StreamTimeoutError } from 'stream-guard';\r\n * import { createReadStream } from 'node:fs';\r\n * \r\n * const stream = guard(createReadStream('file.txt'), {\r\n *   timeout: 30000,      // 30s absolute timeout\r\n *   stalled: 5000,       // 5s stall detection\r\n *   maxBytes: 10 * 1024 * 1024, // 10MB limit\r\n * });\r\n * \r\n * stream.on('error', (err) => {\r\n *   if (err instanceof StreamTimeoutError) {\r\n *     console.log('Stream timed out!');\r\n *   }\r\n * });\r\n * \r\n * stream.pipe(destination);\r\n * ```\r\n */\r\nexport function guard<T extends GuardableStream>(stream: T, options: GuardOptions = {}): T {\r\n  // Validate options\r\n  if (options.timeout !== undefined && (options.timeout <= 0 || !Number.isFinite(options.timeout))) {\r\n    throw new TypeError('timeout must be a positive finite number');\r\n  }\r\n  if (options.stalled !== undefined && (options.stalled <= 0 || !Number.isFinite(options.stalled))) {\r\n    throw new TypeError('stalled must be a positive finite number');\r\n  }\r\n  if (options.maxBytes !== undefined && (options.maxBytes <= 0 || !Number.isFinite(options.maxBytes))) {\r\n    throw new TypeError('maxBytes must be a positive finite number');\r\n  }\r\n  if (options.maxHeap !== undefined && (options.maxHeap <= 0 || !Number.isFinite(options.maxHeap))) {\r\n    throw new TypeError('maxHeap must be a positive finite number');\r\n  }\r\n\r\n  // Check if already guarded\r\n  if (isGuarded(stream)) {\r\n    throw new Error('Stream is already guarded. Call release() first to re-guard.');\r\n  }\r\n\r\n  const {\r\n    timeout,\r\n    stalled,\r\n    maxBytes,\r\n    maxHeap,\r\n    heapCheckInterval = 100,\r\n    heapCheckChunks,\r\n    onDestroy,\r\n  } = options;\r\n\r\n  const guardId = generateGuardId();\r\n\r\n  // Initialize state\r\n  const state: GuardState = {\r\n    startTime: Date.now(),\r\n    lastActivityTime: Date.now(),\r\n    bytesTransferred: 0,\r\n    chunksSinceHeapCheck: 0,\r\n    isDestroyed: false,\r\n    isCompleted: false,\r\n  };\r\n\r\n  // Initialize timers\r\n  const timers: GuardTimers = {\r\n    absoluteTimeout: null,\r\n    stallInterval: null,\r\n    heapInterval: null,\r\n  };\r\n\r\n  /**\r\n   * Clean up all timers and listeners.\r\n   */\r\n  function cleanup(): void {\r\n    if (timers.absoluteTimeout) {\r\n      clearTimeout(timers.absoluteTimeout);\r\n      timers.absoluteTimeout = null;\r\n    }\r\n    if (timers.stallInterval) {\r\n      clearInterval(timers.stallInterval);\r\n      timers.stallInterval = null;\r\n    }\r\n    if (timers.heapInterval) {\r\n      clearInterval(timers.heapInterval);\r\n      timers.heapInterval = null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle stream destruction by guard.\r\n   */\r\n  function destroyWithError(error: Error): void {\r\n    if (state.isDestroyed || state.isCompleted) {\r\n      return;\r\n    }\r\n    state.isDestroyed = true;\r\n    cleanup();\r\n    \r\n    if (onDestroy) {\r\n      try {\r\n        onDestroy(error);\r\n      } catch {\r\n        // Ignore callback errors\r\n      }\r\n    }\r\n    \r\n    safeDestroy(stream, error);\r\n  }\r\n\r\n  /**\r\n   * Mark activity timestamp.\r\n   */\r\n  function recordActivity(): void {\r\n    state.lastActivityTime = Date.now();\r\n  }\r\n\r\n  /**\r\n   * Handle chunk processing for byte counting and heap checks.\r\n   */\r\n  function processChunk(chunk: unknown): void {\r\n    if (state.isDestroyed || state.isCompleted) {\r\n      return;\r\n    }\r\n\r\n    recordActivity();\r\n\r\n    // Track bytes\r\n    const chunkSize = getChunkSize(chunk);\r\n    state.bytesTransferred += chunkSize;\r\n\r\n    // Check byte limit\r\n    if (maxBytes !== undefined && state.bytesTransferred > maxBytes) {\r\n      destroyWithError(new StreamLimitError(maxBytes, state.bytesTransferred));\r\n      return;\r\n    }\r\n\r\n    // Check heap on chunk interval if configured\r\n    if (maxHeap !== undefined && heapCheckChunks !== undefined) {\r\n      state.chunksSinceHeapCheck++;\r\n      if (state.chunksSinceHeapCheck >= heapCheckChunks) {\r\n        state.chunksSinceHeapCheck = 0;\r\n        checkHeap();\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Check heap memory usage.\r\n   */\r\n  function checkHeap(): void {\r\n    if (maxHeap === undefined || state.isDestroyed || state.isCompleted) {\r\n      return;\r\n    }\r\n\r\n    const heapUsed = process.memoryUsage().heapUsed;\r\n    if (heapUsed > maxHeap) {\r\n      destroyWithError(new StreamHeapError(maxHeap, heapUsed));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle stream completion.\r\n   */\r\n  function handleComplete(): void {\r\n    if (state.isCompleted) {\r\n      return;\r\n    }\r\n    state.isCompleted = true;\r\n    cleanup();\r\n  }\r\n\r\n  // Set up absolute timeout\r\n  if (timeout !== undefined) {\r\n    timers.absoluteTimeout = setTimeout(() => {\r\n      const elapsed = Date.now() - state.startTime;\r\n      destroyWithError(new StreamTimeoutError(timeout, elapsed));\r\n    }, timeout);\r\n    \r\n    // Unref to not keep the process alive\r\n    if (timers.absoluteTimeout.unref) {\r\n      timers.absoluteTimeout.unref();\r\n    }\r\n  }\r\n\r\n  // Set up stall detection\r\n  if (stalled !== undefined) {\r\n    timers.stallInterval = setInterval(() => {\r\n      if (state.isDestroyed || state.isCompleted) {\r\n        return;\r\n      }\r\n      \r\n      const idleTime = Date.now() - state.lastActivityTime;\r\n      if (idleTime >= stalled) {\r\n        destroyWithError(new StreamStalledError(stalled, idleTime));\r\n      }\r\n    }, Math.min(stalled / 2, 1000)); // Check at half the stall interval, max every second\r\n    \r\n    if (timers.stallInterval.unref) {\r\n      timers.stallInterval.unref();\r\n    }\r\n  }\r\n\r\n  // Set up heap monitoring interval\r\n  if (maxHeap !== undefined) {\r\n    timers.heapInterval = setInterval(() => {\r\n      checkHeap();\r\n    }, heapCheckInterval);\r\n    \r\n    if (timers.heapInterval.unref) {\r\n      timers.heapInterval.unref();\r\n    }\r\n  }\r\n\r\n  // Cast stream to use generic event emitter interface\r\n  const emitter = stream as DestroyableStream;\r\n\r\n  // Listen to data events (for Readable streams)\r\n  emitter.on('data', processChunk);\r\n\r\n  // Listen to drain events (for Writable streams)\r\n  emitter.on('drain', recordActivity);\r\n\r\n  // Listen to completion events\r\n  emitter.on('end', handleComplete);\r\n  emitter.on('finish', handleComplete);\r\n  emitter.on('close', handleComplete);\r\n  emitter.on('error', handleComplete);\r\n\r\n  // Attach metadata\r\n  const metadata: GuardMetadata = {\r\n    guardId,\r\n    startTime: state.startTime,\r\n    getBytesTransferred: () => state.bytesTransferred,\r\n    getElapsedTime: () => Date.now() - state.startTime,\r\n    isActive: () => !state.isDestroyed && !state.isCompleted,\r\n    release: () => {\r\n      cleanup();\r\n      delete (stream as unknown as StreamWithMetadata)[GUARD_METADATA];\r\n    },\r\n  };\r\n\r\n  Object.defineProperty(stream, GUARD_METADATA, {\r\n    value: metadata,\r\n    writable: false,\r\n    enumerable: false,\r\n    configurable: true,\r\n  });\r\n\r\n  return stream;\r\n}\r\n\r\n/**\r\n * Creates a pre-configured guard factory with default options.\r\n * Useful for applying consistent settings across multiple streams.\r\n * \r\n * @param defaultOptions - Default options for all guards created by this factory\r\n * @returns A guard function with defaults pre-applied\r\n * \r\n * @example\r\n * ```ts\r\n * const apiGuard = createGuard({\r\n *   timeout: 30000,\r\n *   maxBytes: 5 * 1024 * 1024,\r\n * });\r\n * \r\n * // All streams will have these defaults\r\n * apiGuard(stream1);\r\n * apiGuard(stream2, { stalled: 5000 }); // Can override\r\n * ```\r\n */\r\nexport function createGuard(defaultOptions: GuardOptions): <T extends GuardableStream>(stream: T, options?: GuardOptions) => T {\r\n  return <T extends GuardableStream>(stream: T, options: GuardOptions = {}): T => {\r\n    return guard(stream, { ...defaultOptions, ...options });\r\n  };\r\n}\r\n\r\n// Default export for convenience\r\nexport default guard;\r\n"],"mappings":"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","names":[]}