immortal-js 1.0.0

package/packages/core/test/bulkhead.test.ts

@@ -0,0 +1,310 @@
+/**
+ * @file bulkhead.test.ts
+ * @description Tests for BulkheadPool and BulkheadRegistry.
+ *
+ * Actual API (from source):
+ *   new BulkheadPool(name: string, config?: BulkheadConfig)
+ *   pool.run(task, priority?, timeoutMs?)   — priority: "critical"|"high"|"medium"|"low"
+ *   pool.getStatus()   → { name, active, queued, maxConcurrent, maxQueueSize, rejected, totalExecuted }
+ *   pool.drain()       — rejects all queued items, synchronous
+ *
+ *   new BulkheadRegistry(defaultConfig?)
+ *   registry.get(name, config?)   → BulkheadPool (creates or reuses)
+ *   registry.getAllStatuses()      → Record<string, BulkheadStatus>
+ *   registry.drainAll()
+ *
+ * BulkheadStatus.rejected  (NOT "totalRejected")
+ * BulkheadStatus.totalExecuted
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { BulkheadPool, BulkheadRegistry } from "../src/isolation/BulkheadPool.js";
+import { BulkheadRejectedError } from "../src/types.js";
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+function slowTask<T>(value: T, holdMs: number): () => Promise<T> {
+  return () => sleep(holdMs).then(() => value);
+}
+
+// ─── BulkheadPool — basic concurrency ────────────────────────────────────────
+
+describe("BulkheadPool — basic execution", () => {
+  it("executes a single task and returns its result", async () => {
+    const pool = new BulkheadPool("test", { maxConcurrent: 2, maxQueueSize: 5 });
+    const result = await pool.run(() => Promise.resolve(42));
+    expect(result).toBe(42);
+    pool.drain();
+  });
+
+  it("runs up to maxConcurrent tasks simultaneously", async () => {
+    const pool = new BulkheadPool("concurrency", { maxConcurrent: 3, maxQueueSize: 10 });
+    let running = 0;
+    let maxObserved = 0;
+
+    const tasks = Array.from({ length: 3 }, () =>
+      pool.run(async () => {
+        running++;
+        maxObserved = Math.max(maxObserved, running);
+        await sleep(40);
+        running--;
+      })
+    );
+
+    await Promise.all(tasks);
+    expect(maxObserved).toBe(3);
+    pool.drain();
+  });
+
+  it("propagates task errors without blocking the pool", async () => {
+    const pool = new BulkheadPool("errors", { maxConcurrent: 2, maxQueueSize: 5 });
+    await expect(pool.run(() => Promise.reject(new Error("boom")))).rejects.toThrow("boom");
+    // Pool should still be usable
+    const result = await pool.run(() => Promise.resolve("ok"));
+    expect(result).toBe("ok");
+    pool.drain();
+  });
+
+  it("queues tasks beyond maxConcurrent and executes them in order", async () => {
+    const pool = new BulkheadPool("ordering", { maxConcurrent: 1, maxQueueSize: 5 });
+    const order: number[] = [];
+
+    const p1 = pool.run(async () => { await sleep(30); order.push(1); });
+    const p2 = pool.run(async () => { order.push(2); });
+    const p3 = pool.run(async () => { order.push(3); });
+
+    await Promise.all([p1, p2, p3]);
+    expect(order).toEqual([1, 2, 3]);
+    pool.drain();
+  });
+});
+
+// ─── BulkheadPool — rejection ────────────────────────────────────────────────
+
+describe("BulkheadPool — rejection when saturated", () => {
+  it("throws BulkheadRejectedError when queue is full", async () => {
+    // maxQueueSize: 0 → any task that can't run immediately is rejected
+    const pool = new BulkheadPool("saturated", { maxConcurrent: 1, maxQueueSize: 0 });
+
+    const blocker = pool.run(slowTask(null, 100));
+    await expect(pool.run(() => Promise.resolve("x"))).rejects.toBeInstanceOf(BulkheadRejectedError);
+
+    await blocker;
+    pool.drain();
+  });
+
+  it("includes pool name in BulkheadRejectedError message", async () => {
+    const pool = new BulkheadPool("payments", { maxConcurrent: 1, maxQueueSize: 0 });
+    const blocker = pool.run(slowTask(null, 100));
+
+    try {
+      await pool.run(() => Promise.resolve("x"));
+      expect.fail("Should have thrown");
+    } catch (err) {
+      expect(err).toBeInstanceOf(BulkheadRejectedError);
+      expect((err as BulkheadRejectedError).message).toContain("payments");
+    }
+
+    await blocker;
+    pool.drain();
+  });
+
+  it("accepts new tasks once a slot frees up", async () => {
+    const pool = new BulkheadPool("recover", { maxConcurrent: 1, maxQueueSize: 0 });
+    const p1 = pool.run(slowTask("first", 30));
+    await expect(pool.run(() => Promise.resolve("x"))).rejects.toBeInstanceOf(BulkheadRejectedError);
+
+    await p1;
+    const result = await pool.run(() => Promise.resolve("second"));
+    expect(result).toBe("second");
+    pool.drain();
+  });
+
+  it("increments rejected count in getStatus()", async () => {
+    const pool = new BulkheadPool("count", { maxConcurrent: 1, maxQueueSize: 0 });
+    const blocker = pool.run(slowTask(null, 100));
+
+    try { await pool.run(() => Promise.resolve(1)); } catch { /* expected */ }
+    try { await pool.run(() => Promise.resolve(2)); } catch { /* expected */ }
+
+    const status = pool.getStatus();
+    expect(status.rejected).toBeGreaterThanOrEqual(2);
+
+    await blocker;
+    pool.drain();
+  });
+});
+
+// ─── BulkheadPool — priority queues ──────────────────────────────────────────
+
+describe("BulkheadPool — priority queuing", () => {
+  it("drains critical tasks before lower-priority ones", async () => {
+    const pool = new BulkheadPool("priority", { maxConcurrent: 1, maxQueueSize: 20 });
+    const completed: string[] = [];
+
+    // Occupy the one concurrent slot
+    const blocker = pool.run(slowTask(null, 80));
+
+    const promises = [
+      pool.run(async () => { completed.push("low"); }, "low"),
+      pool.run(async () => { completed.push("critical-1"); }, "critical"),
+      pool.run(async () => { completed.push("medium"); }, "medium"),
+      pool.run(async () => { completed.push("high"); }, "high"),
+      pool.run(async () => { completed.push("critical-2"); }, "critical"),
+    ];
+
+    await blocker;
+    await Promise.all(promises);
+
+    const critIdx1 = completed.indexOf("critical-1");
+    const critIdx2 = completed.indexOf("critical-2");
+    const highIdx = completed.indexOf("high");
+    const medIdx = completed.indexOf("medium");
+    const lowIdx = completed.indexOf("low");
+
+    // critical before high
+    expect(Math.max(critIdx1, critIdx2)).toBeLessThan(highIdx);
+    // high before medium
+    expect(highIdx).toBeLessThan(medIdx);
+    // medium before low
+    expect(medIdx).toBeLessThan(lowIdx);
+    pool.drain();
+  });
+});
+
+// ─── BulkheadPool — queue timeout ────────────────────────────────────────────
+
+describe("BulkheadPool — per-item queue timeout", () => {
+  it("rejects queued tasks that wait longer than queueTimeoutMs", async () => {
+    const pool = new BulkheadPool("timeout", {
+      maxConcurrent: 1,
+      maxQueueSize: 5,
+      queueTimeoutMs: 50,
+    });
+
+    const blocker = pool.run(slowTask(null, 300));
+
+    // This task will queue, but queue timeout is 50ms
+    await expect(
+      pool.run(() => Promise.resolve("queued-task"))
+    ).rejects.toBeInstanceOf(BulkheadRejectedError);
+
+    await blocker;
+    pool.drain();
+  });
+});
+
+// ─── BulkheadPool — status reporting ─────────────────────────────────────────
+
+describe("BulkheadPool — getStatus()", () => {
+  it("reports correct active, queued, maxConcurrent counts", async () => {
+    const pool = new BulkheadPool("status", { maxConcurrent: 2, maxQueueSize: 10 });
+
+    const b1 = pool.run(slowTask(null, 200));
+    const b2 = pool.run(slowTask(null, 200));
+    const q1 = pool.run(slowTask(null, 10));
+    const q2 = pool.run(slowTask(null, 10));
+
+    await sleep(10); // let tasks settle
+
+    const status = pool.getStatus();
+    expect(status.active).toBe(2);
+    expect(status.queued).toBe(2);
+    expect(status.maxConcurrent).toBe(2);
+    expect(status.maxQueueSize).toBe(10);
+    expect(status.name).toBe("status");
+
+    await Promise.all([b1, b2, q1, q2]);
+    pool.drain();
+  });
+
+  it("increments totalExecuted after successful runs", async () => {
+    const pool = new BulkheadPool("execcount", { maxConcurrent: 5, maxQueueSize: 10 });
+    await pool.run(() => Promise.resolve("a"));
+    await pool.run(() => Promise.resolve("b"));
+    await pool.run(() => Promise.resolve("c"));
+    const status = pool.getStatus();
+    expect(status.totalExecuted).toBeGreaterThanOrEqual(3);
+    pool.drain();
+  });
+});
+
+// ─── BulkheadPool — drain() ───────────────────────────────────────────────────
+
+describe("BulkheadPool — drain()", () => {
+  it("rejects all queued tasks immediately", async () => {
+    const pool = new BulkheadPool("drain-test", { maxConcurrent: 1, maxQueueSize: 10 });
+    const _blocker = pool.run(slowTask(null, 500));
+
+    const queued1 = pool.run(() => Promise.resolve("q1"));
+    const queued2 = pool.run(() => Promise.resolve("q2"));
+
+    // Drain immediately — queued tasks should be rejected
+    pool.drain();
+
+    await expect(queued1).rejects.toBeInstanceOf(BulkheadRejectedError);
+    await expect(queued2).rejects.toBeInstanceOf(BulkheadRejectedError);
+  });
+});
+
+// ─── BulkheadRegistry ────────────────────────────────────────────────────────
+
+describe("BulkheadRegistry", () => {
+  let registry: BulkheadRegistry;
+
+  beforeEach(() => {
+    registry = new BulkheadRegistry();
+  });
+
+  afterEach(() => {
+    registry.drainAll();
+  });
+
+  it("returns the same BulkheadPool instance for the same name", () => {
+    const p1 = registry.get("payments");
+    const p2 = registry.get("payments");
+    expect(p1).toBe(p2);
+  });
+
+  it("returns different pool instances for different names", () => {
+    const payments = registry.get("payments");
+    const orders = registry.get("orders");
+    expect(payments).not.toBe(orders);
+  });
+
+  it("applies custom config when creating a named pool", async () => {
+    const pool = registry.get("narrow", { maxConcurrent: 1, maxQueueSize: 0 });
+    const blocker = pool.run(slowTask(null, 50));
+    await expect(pool.run(() => Promise.resolve("x"))).rejects.toBeInstanceOf(BulkheadRejectedError);
+    await blocker;
+    pool.drain();
+  });
+
+  it("getAllStatuses() includes all registered pool names", () => {
+    registry.get("svc-a", { maxConcurrent: 5 });
+    registry.get("svc-b", { maxConcurrent: 3 });
+
+    const all = registry.getAllStatuses();
+    expect(all).toHaveProperty("svc-a");
+    expect(all).toHaveProperty("svc-b");
+    expect(all["svc-a"]?.maxConcurrent).toBe(5);
+    expect(all["svc-b"]?.maxConcurrent).toBe(3);
+  });
+
+  it("drainAll() does not throw even with empty registry", () => {
+    expect(() => registry.drainAll()).not.toThrow();
+  });
+
+  it("uses default config for pools created without explicit config", () => {
+    const reg = new BulkheadRegistry({ maxConcurrent: 10, maxQueueSize: 50 });
+    const pool = reg.get("default-pool");
+    const status = pool.getStatus();
+    expect(status.maxConcurrent).toBe(10);
+    expect(status.maxQueueSize).toBe(50);
+    reg.drainAll();
+  });
+});

package/packages/core/test/circuit-breaker.test.ts

@@ -0,0 +1,153 @@
+/**
+ * @file circuit-breaker.test.ts
+ * @description Tests for CircuitBreaker state machine
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../src/event-bus.js", () => ({
+  getEventBus: () => ({ emit: vi.fn() }),
+}));
+
+vi.mock("../src/logger.js", () => ({
+  getLogger: () => ({ debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() }),
+}));
+
+const { CircuitBreaker, CircuitBreakerRegistry } = await import("../src/recovery/CircuitBreaker.js");
+const { CircuitOpenError } = await import("../src/types.js");
+
+describe("CircuitBreaker", () => {
+  it("should start in CLOSED state", () => {
+    const breaker = new CircuitBreaker("test", {});
+    expect(breaker.getCurrentState()).toBe("CLOSED");
+  });
+
+  it("should pass through operations when CLOSED", async () => {
+    const breaker = new CircuitBreaker("test", { threshold: 5, minimumRequests: 5 });
+    const result = await breaker.execute(async () => "hello");
+    expect(result).toBe("hello");
+    expect(breaker.getCurrentState()).toBe("CLOSED");
+  });
+
+  it("should OPEN after threshold failures", async () => {
+    const breaker = new CircuitBreaker("test", {
+      threshold: 3,
+      minimumRequests: 3,
+      failureRateThreshold: 50,
+      slidingWindowSize: 10,
+    });
+
+    const failFn = async () => { throw new Error("service down"); };
+
+    // Trigger enough failures to open the circuit
+    for (let i = 0; i < 5; i++) {
+      try { await breaker.execute(failFn); } catch { /* expected */ }
+    }
+
+    expect(breaker.getCurrentState()).toBe("OPEN");
+  });
+
+  it("should use fallback when OPEN", async () => {
+    const breaker = new CircuitBreaker("test", {
+      threshold: 2,
+      minimumRequests: 2,
+      failureRateThreshold: 50,
+      slidingWindowSize: 5,
+    });
+
+    // Open the circuit
+    for (let i = 0; i < 5; i++) {
+      try {
+        await breaker.execute(async () => { throw new Error("fail"); });
+      } catch { /* expected */ }
+    }
+
+    expect(breaker.getCurrentState()).toBe("OPEN");
+
+    // Should use fallback without throwing
+    const result = await breaker.execute(
+      async () => "normal",
+      () => "fallback-value"
+    );
+    expect(result).toBe("fallback-value");
+  });
+
+  it("should throw CircuitOpenError when OPEN and no fallback", async () => {
+    const breaker = new CircuitBreaker("payment", {
+      threshold: 2,
+      minimumRequests: 2,
+      failureRateThreshold: 50,
+      slidingWindowSize: 5,
+    });
+
+    for (let i = 0; i < 5; i++) {
+      try {
+        await breaker.execute(async () => { throw new Error("fail"); });
+      } catch { /* expected */ }
+    }
+
+    await expect(
+      breaker.execute(async () => "should not run")
+    ).rejects.toBeInstanceOf(CircuitOpenError);
+  });
+
+  it("should reset to CLOSED after successful HALF_OPEN probe", async () => {
+    const breaker = new CircuitBreaker("test", {
+      threshold: 2,
+      minimumRequests: 2,
+      failureRateThreshold: 50,
+      slidingWindowSize: 5,
+      cooldownMs: 0, // Instant cooldown for testing
+    });
+
+    // Open circuit
+    for (let i = 0; i < 5; i++) {
+      try {
+        await breaker.execute(async () => { throw new Error("fail"); });
+      } catch { /* expected */ }
+    }
+
+    expect(breaker.getCurrentState()).toBe("OPEN");
+
+    // Force state to HALF_OPEN (simulating cooldown elapsed)
+    breaker.forceState("HALF_OPEN");
+    expect(breaker.getCurrentState()).toBe("HALF_OPEN");
+
+    // Successful probe should close circuit
+    const result = await breaker.execute(async () => "probe-success");
+    expect(result).toBe("probe-success");
+    expect(breaker.getCurrentState()).toBe("CLOSED");
+  });
+
+  it("should correctly report status", () => {
+    const breaker = new CircuitBreaker("metrics-test", { threshold: 10 });
+    const status = breaker.getStatus();
+
+    expect(status.name).toBe("metrics-test");
+    expect(status.state).toBe("CLOSED");
+    expect(status.failures).toBe(0);
+    expect(status.failureRate).toBe(0);
+  });
+});
+
+describe("CircuitBreakerRegistry", () => {
+  it("should create and reuse named circuit breakers", () => {
+    const registry = new CircuitBreakerRegistry({ threshold: 5 });
+
+    const c1 = registry.get("payments");
+    const c2 = registry.get("payments");
+
+    expect(c1).toBe(c2); // Same instance
+    expect(c1.name).toBe("payments");
+  });
+
+  it("should return all statuses", () => {
+    const registry = new CircuitBreakerRegistry();
+    registry.get("service-a");
+    registry.get("service-b");
+
+    const statuses = registry.getAllStatuses();
+    expect(Object.keys(statuses)).toContain("service-a");
+    expect(Object.keys(statuses)).toContain("service-b");
+  });
+});

package/packages/core/test/memory-guard.test.ts

@@ -0,0 +1,213 @@
+/**
+ * @file memory-guard.test.ts
+ * @description Tests for MemoryLeakGuard.
+ *
+ * Actual API (from source):
+ *   new MemoryLeakGuard(config?: MemoryGuardConfig, bus: ImmortalEventBus)
+ *   guard.start()
+ *   guard.stop()
+ *   guard.trackObject(obj, name, expectedGcMs?)
+ *   guard["computeGrowthRate"](values) — private, tested via bracket access
+ *
+ * The class does NOT expose: isRunning(), getCurrentStats(), getTrackedNames()
+ * It uses the ImmortalEventBus for all emitted events.
+ * restartCooldownMs is not a config field; the field is "growthWindowCount".
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { MemoryLeakGuard } from "../src/monitoring/MemoryLeakGuard.js";
+import { getEventBus } from "../src/event-bus.js";
+import type { ImmortalEventBus } from "../src/event-bus.js";
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+/** Returns a real event bus instance (singleton) */
+function bus(): ImmortalEventBus {
+  return getEventBus();
+}
+
+// ─── Construction ─────────────────────────────────────────────────────────────
+
+describe("MemoryLeakGuard — construction", () => {
+  it("creates an instance with default config", () => {
+    const guard = new MemoryLeakGuard({}, bus());
+    expect(guard).toBeDefined();
+    guard.stop();
+  });
+
+  it("creates an instance with custom config", () => {
+    const guard = new MemoryLeakGuard(
+      { checkIntervalMs: 5_000, growthWindowCount: 5, warningThresholdMb: 512 },
+      bus()
+    );
+    expect(guard).toBeDefined();
+    guard.stop();
+  });
+
+  it("does not start monitoring automatically", () => {
+    // If it auto-started, we'd see interval handles — just verify no throw
+    expect(() => {
+      const g = new MemoryLeakGuard({}, bus());
+      g.stop(); // stop immediately — should be a no-op
+    }).not.toThrow();
+  });
+});
+
+// ─── Start / Stop lifecycle ───────────────────────────────────────────────────
+
+describe("MemoryLeakGuard — start / stop lifecycle", () => {
+  it("start() does not throw", () => {
+    const guard = new MemoryLeakGuard({ checkIntervalMs: 60_000 }, bus());
+    expect(() => guard.start()).not.toThrow();
+    guard.stop();
+  });
+
+  it("calling start() twice is idempotent (no throw)", () => {
+    const guard = new MemoryLeakGuard({ checkIntervalMs: 60_000 }, bus());
+    guard.start();
+    guard.start(); // second call should be a no-op
+    guard.stop();
+  });
+
+  it("stop() before start() does not throw", () => {
+    const guard = new MemoryLeakGuard({}, bus());
+    expect(() => guard.stop()).not.toThrow();
+  });
+
+  it("calling stop() twice is idempotent (no throw)", () => {
+    const guard = new MemoryLeakGuard({ checkIntervalMs: 60_000 }, bus());
+    guard.start();
+    guard.stop();
+    expect(() => guard.stop()).not.toThrow(); // second stop is a no-op
+  });
+});
+
+// ─── trackObject ─────────────────────────────────────────────────────────────
+
+describe("MemoryLeakGuard — trackObject", () => {
+  it("does not throw when object tracking is enabled", () => {
+    const guard = new MemoryLeakGuard({ enableObjectTracking: true }, bus());
+    const obj = { type: "db-conn" };
+    expect(() => guard.trackObject(obj, "pg-conn-1")).not.toThrow();
+    guard.stop();
+  });
+
+  it("does nothing (no throw) when object tracking is disabled", () => {
+    const guard = new MemoryLeakGuard({ enableObjectTracking: false }, bus());
+    const obj = { type: "conn" };
+    expect(() => guard.trackObject(obj, "ignored-conn")).not.toThrow();
+    guard.stop();
+  });
+
+  it("accepts optional expectedGcMs parameter", () => {
+    const guard = new MemoryLeakGuard({ enableObjectTracking: true }, bus());
+    const obj = { x: 1 };
+    expect(() => guard.trackObject(obj, "my-obj", 60_000)).not.toThrow();
+    guard.stop();
+  });
+});
+
+// ─── Internal: computeGrowthRate (linear regression) ─────────────────────────
+
+describe("MemoryLeakGuard — computeGrowthRate (linear regression)", () => {
+  it("returns a positive rate for monotonically increasing samples", () => {
+    const guard = new MemoryLeakGuard({ checkIntervalMs: 1_000 }, bus());
+    // Use bracket access to test private method
+    const lr = (guard as unknown as { computeGrowthRate(v: number[]): number }).computeGrowthRate;
+    if (!lr) { guard.stop(); return; }
+
+    // y = 2i + 100  → slope = 2MB per interval → positive growth rate
+    const samples = [100, 102, 104, 106, 108, 110];
+    const rate = lr.call(guard, samples);
+    expect(rate).toBeGreaterThan(0);
+    guard.stop();
+  });
+
+  it("returns near-zero rate for flat / sawtooth samples", () => {
+    const guard = new MemoryLeakGuard({ checkIntervalMs: 1_000 }, bus());
+    const lr = (guard as unknown as { computeGrowthRate(v: number[]): number }).computeGrowthRate;
+    if (!lr) { guard.stop(); return; }
+
+    // Flat
+    const flat = [200, 200, 200, 200, 200, 200];
+    const rate = lr.call(guard, flat);
+    expect(Math.abs(rate)).toBeLessThan(1);
+    guard.stop();
+  });
+
+  it("returns 0 for a single-element array", () => {
+    const guard = new MemoryLeakGuard({ checkIntervalMs: 1_000 }, bus());
+    const lr = (guard as unknown as { computeGrowthRate(v: number[]): number }).computeGrowthRate;
+    if (!lr) { guard.stop(); return; }
+
+    expect(lr.call(guard, [200])).toBe(0);
+    guard.stop();
+  });
+
+  it("returns 0 for empty array", () => {
+    const guard = new MemoryLeakGuard({ checkIntervalMs: 1_000 }, bus());
+    const lr = (guard as unknown as { computeGrowthRate(v: number[]): number }).computeGrowthRate;
+    if (!lr) { guard.stop(); return; }
+
+    expect(lr.call(guard, [])).toBe(0);
+    guard.stop();
+  });
+});
+
+// ─── Event emission ───────────────────────────────────────────────────────────
+
+describe("MemoryLeakGuard — sampling emits events", () => {
+  it("emits memory:warning or memory:critical from the bus after a forced sample", async () => {
+    const eventBus = bus();
+    const guard = new MemoryLeakGuard(
+      {
+        checkIntervalMs: 60_000,
+        // Set thresholds below current heap to force events
+        warningThresholdMb: 0.001,
+        restartThresholdMb: 0.001,
+        growthWindowCount: 1000, // prevent restart
+        adaptiveThresholds: false,
+      },
+      eventBus
+    );
+
+    const events: string[] = [];
+    eventBus.on("memory:warning", () => events.push("warning"));
+    eventBus.on("memory:critical", () => events.push("critical"));
+
+    // Force a sample by calling the private method
+    const sampleFn = (guard as unknown as { sample(): void }).sample;
+    if (sampleFn) {
+      sampleFn.call(guard);
+      await sleep(10);
+      // We expect at least one event (warning or critical)
+      expect(events.length).toBeGreaterThan(0);
+    }
+
+    guard.stop();
+  });
+});
+
+// ─── Default config values ────────────────────────────────────────────────────
+
+describe("MemoryLeakGuard — config merging", () => {
+  it("uses default checkIntervalMs if not provided", () => {
+    const guard = new MemoryLeakGuard({}, bus());
+    // Access private config via bracket — just verify it merged
+    const cfg = (guard as unknown as { config: { checkIntervalMs: number } }).config;
+    expect(typeof cfg.checkIntervalMs).toBe("number");
+    expect(cfg.checkIntervalMs).toBeGreaterThan(0);
+    guard.stop();
+  });
+
+  it("overrides defaults with provided config", () => {
+    const guard = new MemoryLeakGuard({ checkIntervalMs: 99_000 }, bus());
+    const cfg = (guard as unknown as { config: { checkIntervalMs: number } }).config;
+    expect(cfg.checkIntervalMs).toBe(99_000);
+    guard.stop();
+  });
+});