loadscope 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LoadScope Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,292 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<div align="center">
+
+# ⚡ LoadScope
+
+**A high-performance HTTP load tester with automated breaking-point finder, Coordinated Omission correction, CI performance regression gating, and zero-browser PDF/HTML reports.**
+
+[![CI](https://github.com/shaikafridd/loadscope/actions/workflows/ci.yml/badge.svg)](https://github.com/shaikafridd/loadscope/actions)
+[![npm version](https://img.shields.io/badge/npm-v0.1.0-blue.svg)](https://www.npmjs.com/package/loadscope)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.4-blue.svg)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen.svg)](https://nodejs.org/)
+
+</div>
+
+---
+
+## 🚀 Why LoadScope?
+
+Most modern load testing tools suffer from one of three major engineering shortcomings:
+1. **Coordinated Omission**: Closed concurrency models stall the client when the server stalls, hiding catastrophic queueing delays behind polite client waits.
+2. **Missing Automated Capacity Detection**: Finding maximum server capacity requires guessing parameters and manually running dozens of tests.
+3. **Fragile CI & Heavy Reporting**: Generating visual reports traditionally pulls in 200MB+ Chromium binaries (Puppeteer/Playwright) or flaky remote CDNs.
+
+**LoadScope fixes all three.** It provides:
+- **Automated Breaking-Point Finder**: Stepped ramps combined with binary search bisection to discover the exact load where SLAs breach.
+- **Honest Latency Modeling**: Open-model Poisson/Uniform arrival scheduling with Gil Tene Coordinated Omission correction.
+- **CI Performance Regression Gate**: Save reference baselines, enforce directional tolerance budgets (e.g. max 10% p95 increase), and fail CI builds before merging slow code.
+- **Zero-Browser Vector PDF & Interactive HTML Reports**: Lightning-fast (<100ms) vector PDFs via PDFKit and air-gapped, zero-CDN interactive HTML reports with embedded SVG charts.
+- **Constant Memory ($O(1)$)**: Custom 260-bucket logarithmic histogram eliminating garbage collection pauses regardless of test duration or request count.
+
+---
+
+## ⚡ Quick Start
+
+Execute immediately without installation using `npx`:
+
+```bash
+# Standard 10-second benchmark with 50 concurrent connections
+npx loadscope http://localhost:3000/api -c 50 -d 10s
+
+# Find maximum breaking-point capacity automatically
+npx loadscope break http://localhost:3000/api --start 10 --max 200 --step 20 --max-p95 250
+
+# Run open arrival model with Poisson distribution and Honest Latency
+npx loadscope http://localhost:3000/api --rate 500 --distribution poisson --honest
+
+# Generate a publication-grade vector PDF report
+npx loadscope http://localhost:3000/api -c 50 -d 10s --pdf report.pdf
+
+# Generate a self-contained interactive HTML report
+npx loadscope http://localhost:3000/api -c 50 -d 10s --html
+```
+
+### 🖥️ Live Terminal Dashboard Experience
+
+```text
+ 🚀 LoadScope v0.1.0  •  Target: http://localhost:3000/api  •  Workers: 4
+ ────────────────────────────────────────────────────────────────────────
+ Throughput:      3,480 req/s    [████████████████████░░░░░░░░░░]  70%
+ Active Conns:    50 / 50        Dispatched: 34,800 reqs
+ Latency (p50):   12.4 ms        Latency (p95): 38.6 ms  (p99: 89.2 ms)
+ Error Rate:      0.00%          Event Loop Lag: 1.2 ms (Optimal)
+
+ History (p95):   18ms ─── 22ms ─── 28ms ─── 35ms ─── 38ms ─── 39ms ─── 38ms
+ ────────────────────────────────────────────────────────────────────────
+```
+
+### 🎯 Automated Breaking-Point Finder Experience
+
+```text
+ 🔍 LoadScope Breaking-Point Capacity Detection:
+ ────────────────────────────────────────────────────────────────────────
+ [Step 1]  Load:  20 conn  │  3,850 req/s  │  p95:  18.2ms  │  Errors: 0.0%  │  ✅ PASS
+ [Step 2]  Load:  40 conn  │  7,620 req/s  │  p95:  24.5ms  │  Errors: 0.0%  │  ✅ PASS
+ [Step 3]  Load:  60 conn  │ 11,240 req/s  │  p95:  32.1ms  │  Errors: 0.0%  │  ✅ PASS
+ [Step 4]  Load:  80 conn  │ 14,810 req/s  │  p95:  45.8ms  │  Errors: 0.0%  │  ✅ PASS
+ [Step 5]  Load: 100 conn  │ 16,920 req/s  │  p95: 142.0ms  │  Errors: 0.0%  │  ✅ PASS
+ [Step 6]  Load: 120 conn  │ 17,100 req/s  │  p95: 385.2ms  │  Errors: 0.2%  │  ❌ BREACH
+ ────────────────────────────────────────────────────────────────────────
+ ⚡ Binary Search Refinement: Narrowing capacity between 100 and 120...
+ [Refine]  Load: 110 conn  │ 17,250 req/s  │  p95: 220.4ms  │  Errors: 0.0%  │  ✅ PASS
+ [Refine]  Load: 115 conn  │ 17,180 req/s  │  p95: 295.1ms  │  Errors: 0.0%  │  ✅ PASS
+ [Refine]  Load: 117 conn  │ 17,110 req/s  │  p95: 324.8ms  │  Errors: 0.1%  │  ❌ BREACH
+ ────────────────────────────────────────────────────────────────────────
+ 🎯 Result: Maximum Safe Capacity is 115 concurrent connections (p95: 295.1ms)
+```
+
+---
+
+## 📊 Feature Comparison Matrix
+
+| Feature | LoadScope | autocannon | wrk | k6 |
+| :--- | :---: | :---: | :---: | :---: |
+| **Breaking-Point Finder** | ✅ Auto Stepped + Binary Search | ❌ Manual | ❌ Manual | ⚠️ Scripted |
+| **Coordinated Omission Correction** | ✅ Built-in (Gil Tene) | ❌ Closed only | ❌ Closed only | ⚠️ Custom |
+| **Open Arrival Model (Poisson)** | ✅ Native | ❌ | ❌ | ✅ |
+| **CI Regression Gating & Step Summary**| ✅ Native (Exit 1 + PR Table) | ❌ | ❌ | ⚠️ Cloud/Thresholds |
+| **Zero-Browser Vector PDF Reports** | ✅ Built-in (<100ms) | ❌ | ❌ | ❌ |
+| **Air-Gapped Zero-CDN HTML Reports** | ✅ Built-in (SVG) | ❌ | ❌ | ⚠️ Cloud / Plugin |
+| **Multi-Core Worker Threads** | ✅ Auto Core Scaling | ⚠️ Single thread | ✅ Multi-thread | ✅ Multi-thread |
+| **Constant-Memory Histogram** | ✅ $O(1)$ Log Bucketed | ⚠️ HDR JS | ✅ C Struct | ⚠️ Go Runtime |
+| **AI Performance Diagnostics** | ✅ Native Gemini/OpenAI | ❌ | ❌ | ❌ |
+
+---
+
+## 🏗️ Architecture
+
+### 1. Multi-Core Worker Pool Dispatch
+LoadScope scales traffic generation linearly across available physical CPU cores using Node.js Worker Threads with zero shared memory contention.
+
+```mermaid
+graph TD
+    CLI[LoadScope Orchestrator] -->|WorkerInitData| W1[Worker Thread 1]
+    CLI -->|WorkerInitData| W2[Worker Thread 2]
+    CLI -->|WorkerInitData| W3[Worker Thread N]
+    
+    W1 -->|Non-blocking undici pool| Target[Target Web Server]
+    W2 -->|Non-blocking undici pool| Target
+    W3 -->|Non-blocking undici pool| Target
+    
+    W1 -.->|Tick Messages 4Hz| CLI
+    W2 -.->|Tick Messages 4Hz| CLI
+    W3 -.->|Tick Messages 4Hz| CLI
+    
+    CLI --> UI[Live Terminal Dashboard / HTML / PDF]
+```
+
+### 2. Gil Tene Coordinated Omission Correction
+When a server stalls for 1 second, a closed-model load tester stops sending requests, recording a single slow sample while omitting hundreds of virtual users that should have queued. LoadScope backfills virtual requests according to the schedule:
+
+```mermaid
+sequenceDiagram
+    autonumber
+    actor Client as LoadScope Scheduler
+    participant Server as Target Service
+    
+    Note over Client,Server: Scheduled Arrival Interval: 10ms (100 req/s)
+    Client->>Server: Request 1 (T = 0ms)
+    Server-->>Client: Response 1 (T = 10ms) - Latency: 10ms
+    
+    Client->>Server: Request 2 (T = 10ms)
+    Note over Server: Server GC Pause or Database Stall (100ms)
+    Server-->>Client: Response 2 (T = 110ms) - Service Time: 100ms
+    
+    Note over Client: Closed Model records 1 slow sample (100ms).<br/>LoadScope Honest Correction backfills 9 virtual requests<br/>queued at 20ms, 30ms, ... with true honest latency up to 90ms.
+```
+
+### 3. Automated Capacity Detection (Stepped Ramp + Binary Search)
+```mermaid
+graph LR
+    A[Start Load: 20] --> B[Step Load: +20]
+    B --> C{SLA Breach?}
+    C -- No --> B
+    C -- Yes (Breach at 120) --> D[Binary Search Refinement]
+    D --> E[Test Midpoint: 110]
+    E --> F{SLA Breach?}
+    F -- No --> G[Test Upper: 115]
+    F -- Yes --> H[Test Lower: 105]
+    G --> I[Pinpointed Capacity: 118]
+```
+
+---
+
+## 📖 CLI Usage & Command Reference
+
+### Standard Load Test
+```bash
+loadscope <url> [options]
+```
+
+| Option | Flag | Default | Description |
+| :--- | :--- | :---: | :--- |
+| Concurrency | `-c, --concurrency <n>` | `10` | Number of simultaneous HTTP connections |
+| Duration | `-d, --duration <duration>`| `10s` | Test duration (e.g. `10s`, `1m`, `300s`) |
+| Workers | `-W, --workers <n\|auto>` | `1` | Worker threads count (`auto` detects logical cores) |
+| Method | `--method <verb>` | `GET` | HTTP method (GET, POST, PUT, DELETE, etc.) |
+| Headers | `-H, --header <h...>` | - | Custom HTTP headers (`-H "Authorization: Bearer token"`) |
+| Body | `-b, --body <data>` | - | HTTP payload data string |
+| Timeout | `--timeout <duration>` | `10s` | Individual socket timeout |
+| Warmup | `--warmup <duration>` | `0s` | Warmup duration excluded from summary metrics |
+
+### Open Arrival Model & Honest Latency
+```bash
+# Uniform open arrival at 400 req/s with Coordinated Omission correction
+loadscope http://localhost:3000/api --rate 400 --honest
+
+# Poisson arrival distribution (stochastic modeling) with TTFB tracking
+loadscope http://localhost:3000/api --rate 500 --distribution poisson --ttfb --honest
+```
+
+### Breaking-Point Capacity Detection
+```bash
+loadscope break <url> [options]
+```
+
+```bash
+# Automatically ramp from 10 to 200 connections, stepping by 10 every 5 seconds.
+# Breaches if p95 latency exceeds 300ms or error rate exceeds 1%.
+loadscope break http://localhost:3000/api \
+  --start 10 \
+  --max 200 \
+  --step 10 \
+  --step-duration 5s \
+  --max-p95 300 \
+  --max-errors 1.0 \
+  --tolerance 2
+```
+
+### CI/CD Regression Gate
+```bash
+# 1. Capture reference performance baseline on main branch
+loadscope http://localhost:3000/api -c 50 -d 15s --save-baseline baseline.json
+
+# 2. In PR CI pipeline: evaluate against baseline (fails with exit code 1 if degraded)
+loadscope http://localhost:3000/api -c 50 -d 15s \
+  --baseline baseline.json \
+  --max-p95-increase 10 \
+  --max-rps-drop 5
+
+# 3. Offline comparison between two JSON runs
+loadscope compare current-run.json baseline.json --max-p95-increase 10
+```
+
+### Visual & Machine-Readable Exports
+```bash
+# Self-contained interactive HTML report (Zero CDN, air-gapped ready)
+loadscope http://localhost:3000/api -c 50 -d 10s --html report.html
+
+# Multi-page vector PDF benchmark report (<100ms render, zero Puppeteer)
+loadscope http://localhost:3000/api -c 50 -d 10s --pdf report.pdf
+
+# Vector PDF report with automated AI Performance Diagnostics
+export GEMINI_API_KEY="your-gemini-key"
+loadscope http://localhost:3000/api -c 50 -d 10s --ai-report report-ai.pdf
+
+# Machine-readable JSON or CSV for monitoring pipelines
+loadscope http://localhost:3000/api -c 50 -d 10s --json results.json --csv results.csv
+```
+
+---
+
+## 💻 Programmatic TypeScript SDK
+
+LoadScope provides a clean, fully-typed programmatic API for custom Node.js automation:
+
+```typescript
+import { run, runBreakingPoint, generatePdfReport, generateHtmlReport } from "loadscope";
+
+// 1. Standard Benchmark Run
+const summary = await run({
+  url: "https://api.example.com/checkout",
+  concurrency: 50,
+  duration: 10,
+  honest: true,
+  workers: "auto",
+});
+
+console.log(`Throughput: ${summary.rps} req/s`);
+console.log(`p95 Latency: ${summary.p95} ms`);
+console.log(`Error Rate: ${(summary.errorRate * 100).toFixed(2)}%`);
+
+// 2. Generate Interactive HTML & Vector PDF Reports
+await generateHtmlReport(summary, "artifacts/report.html");
+await generatePdfReport(summary, "artifacts/report.pdf");
+
+// 3. Automated Breaking-Point Search
+const bpResult = await runBreakingPoint({
+  url: "https://api.example.com/checkout",
+  start: 10,
+  max: 300,
+  step: 25,
+  maxP95: 250,
+  maxErrorRate: 0.01,
+});
+
+if (bpResult.breakingPointReached) {
+  console.log(`Service saturated at ${bpResult.maxSustainedLoad} connections!`);
+  console.log(`Breach reason: ${bpResult.breachReason}`);
+}
+```
+
+---
+
+## 🤝 Contributing
+
+We welcome pull requests and issues! Please read our [Contributing Guide](CONTRIBUTING.md) for details on development workflows, test execution, and code style.
+
+---
+
+## 📄 License
+
+This project is open-source software licensed under the [MIT License](LICENSE).

package/dist/chunk-7L4SENK7.js

@@ -0,0 +1,269 @@
+// src/stats/histogram.ts
+var GROWTH = 1.02;
+var BUCKETS = 1200;
+var Histogram = class {
+  /** Fixed 4.8 KB bucket array of counts */
+  counts = new Uint32Array(BUCKETS);
+  /** Total number of recorded samples */
+  total = 0;
+  minVal = Infinity;
+  maxVal = 0;
+  sumUs = 0;
+  /**
+   * Calculate bucket index from latency in microseconds.
+   * O(1) mathematical mapping.
+   */
+  idx(us) {
+    if (us <= 1) return 0;
+    const bucket = Math.floor(Math.log(us) / Math.log(GROWTH));
+    return Math.min(BUCKETS - 1, Math.max(0, bucket));
+  }
+  /**
+   * Reconstruct microsecond value from bucket index.
+   */
+  valFromIdx(i) {
+    return Math.pow(GROWTH, i + 1);
+  }
+  /**
+   * Record a latency value in microseconds (us).
+   */
+  record(us) {
+    const val = Math.max(0, us);
+    const i = this.idx(val);
+    this.counts[i]++;
+    this.total++;
+    this.sumUs += val;
+    if (val < this.minVal) this.minVal = val;
+    if (val > this.maxVal) this.maxVal = val;
+  }
+  /**
+   * Merge another histogram into this one.
+   * Merging is simple O(B) vector addition across the fixed bucket array.
+   */
+  merge(other) {
+    for (let i = 0; i < BUCKETS; i++) {
+      this.counts[i] += other.counts[i];
+    }
+    this.total += other.total;
+    this.sumUs += other.sumUs;
+    if (other.minVal < this.minVal) this.minVal = other.minVal;
+    if (other.maxVal > this.maxVal) this.maxVal = other.maxVal;
+  }
+  /**
+   * Calculate the given percentile (0..100) in microseconds (us).
+   */
+  percentile(p) {
+    if (this.total === 0) return 0;
+    if (p <= 0) return this.min();
+    if (p >= 100) return this.max();
+    const target = Math.ceil(p / 100 * this.total);
+    let seen = 0;
+    for (let i = 0; i < BUCKETS; i++) {
+      seen += this.counts[i];
+      if (seen >= target) {
+        const val = this.valFromIdx(i);
+        return Math.min(Math.max(val, this.minVal), this.maxVal);
+      }
+    }
+    return this.max();
+  }
+  /**
+   * Return percentile in milliseconds (ms).
+   */
+  percentileMs(p) {
+    return this.percentile(p) / 1e3;
+  }
+  /**
+   * Minimum recorded latency in microseconds (us).
+   */
+  min() {
+    return this.total === 0 ? 0 : this.minVal;
+  }
+  /**
+   * Minimum recorded latency in milliseconds (ms).
+   */
+  minMs() {
+    return this.min() / 1e3;
+  }
+  /**
+   * Maximum recorded latency in microseconds (us).
+   */
+  max() {
+    return this.total === 0 ? 0 : this.maxVal;
+  }
+  /**
+   * Maximum recorded latency in milliseconds (ms).
+   */
+  maxMs() {
+    return this.max() / 1e3;
+  }
+  /**
+   * Mean (average) latency in microseconds (us).
+   */
+  mean() {
+    return this.total === 0 ? 0 : this.sumUs / this.total;
+  }
+  /**
+   * Mean (average) latency in milliseconds (ms).
+   */
+  meanMs() {
+    return this.mean() / 1e3;
+  }
+  /**
+   * Reset all bucket counts and statistics.
+   */
+  reset() {
+    this.counts.fill(0);
+    this.total = 0;
+    this.sumUs = 0;
+    this.minVal = Infinity;
+    this.maxVal = 0;
+  }
+  /**
+   * Export raw snapshot data for inter-thread messaging (worker_threads).
+   */
+  toSnapshot() {
+    return {
+      counts: new Uint32Array(this.counts),
+      total: this.total,
+      minVal: this.minVal,
+      maxVal: this.maxVal,
+      sumUs: this.sumUs
+    };
+  }
+  /**
+   * Restore or merge from a worker snapshot.
+   */
+  mergeSnapshot(snapshot) {
+    for (let i = 0; i < BUCKETS; i++) {
+      this.counts[i] += snapshot.counts[i];
+    }
+    this.total += snapshot.total;
+    this.sumUs += snapshot.sumUs;
+    if (snapshot.minVal < this.minVal) this.minVal = snapshot.minVal;
+    if (snapshot.maxVal > this.maxVal) this.maxVal = snapshot.maxVal;
+  }
+};
+
+// src/stats/co-corrector.ts
+function recordWithCorrection(histogram, latencyUs, expectedIntervalUs) {
+  const primaryVal = Math.max(0, latencyUs);
+  histogram.record(primaryVal);
+  if (expectedIntervalUs <= 0 || primaryVal <= expectedIntervalUs) {
+    return 1;
+  }
+  let totalSamplesAdded = 1;
+  let virtualLatencyUs = primaryVal - expectedIntervalUs;
+  while (virtualLatencyUs > 0) {
+    histogram.record(virtualLatencyUs);
+    totalSamplesAdded++;
+    virtualLatencyUs -= expectedIntervalUs;
+  }
+  return totalSamplesAdded;
+}
+function extractDistribution(h) {
+  return {
+    p50: h.percentileMs(50),
+    p90: h.percentileMs(90),
+    p95: h.percentileMs(95),
+    p99: h.percentileMs(99),
+    min: h.minMs(),
+    max: h.maxMs(),
+    mean: h.meanMs()
+  };
+}
+function computeQueueDelay(response, service) {
+  return {
+    p50: Math.max(0, response.p50 - service.p50),
+    p90: Math.max(0, response.p90 - service.p90),
+    p95: Math.max(0, response.p95 - service.p95),
+    p99: Math.max(0, response.p99 - service.p99),
+    min: Math.max(0, response.min - service.min),
+    max: Math.max(0, response.max - service.max),
+    mean: Math.max(0, response.mean - service.mean)
+  };
+}
+
+// src/core/scheduler.ts
+var ArrivalScheduler = class {
+  rate;
+  distribution;
+  startNs;
+  currentScheduledNs;
+  totalDriftNs = 0n;
+  sampleCount = 0;
+  maxDriftNs = 0n;
+  constructor(rate, distribution = "uniform", startNs) {
+    this.rate = Math.max(0.1, rate);
+    this.distribution = distribution;
+    this.startNs = startNs ?? process.hrtime.bigint();
+    this.currentScheduledNs = this.startNs;
+  }
+  /**
+   * Generates the next scheduled arrival timestamp (in nanoseconds).
+   */
+  nextArrivalNs() {
+    if (this.distribution === "poisson") {
+      const u = Math.max(1e-10, 1 - Math.random());
+      const intervalSec = -Math.log(u) / this.rate;
+      const intervalNs = BigInt(Math.max(1, Math.floor(intervalSec * 1e9)));
+      this.currentScheduledNs += intervalNs;
+    } else {
+      const intervalNs = BigInt(Math.max(1, Math.floor(1e9 / this.rate)));
+      this.currentScheduledNs += intervalNs;
+    }
+    return this.currentScheduledNs;
+  }
+  /**
+   * High-resolution pause until the target timestamp is reached.
+   * Uses setTimeout for long waits and micro-spinning for sub-millisecond precision.
+   */
+  async waitUntil(targetNs) {
+    const now = process.hrtime.bigint();
+    if (now >= targetNs) {
+      this.recordDrift(now - targetNs);
+      return;
+    }
+    const diffNs = targetNs - now;
+    const diffMs = Number(diffNs) / 1e6;
+    if (diffMs > 2) {
+      await new Promise((resolve) => setTimeout(resolve, Math.floor(diffMs - 1)));
+    }
+    while (process.hrtime.bigint() < targetNs) {
+      if (Number(targetNs - process.hrtime.bigint()) > 5e5) {
+        await new Promise((r) => setImmediate(r));
+      }
+    }
+    const actual = process.hrtime.bigint();
+    this.recordDrift(actual > targetNs ? actual - targetNs : 0n);
+  }
+  recordDrift(driftNs) {
+    this.totalDriftNs += driftNs;
+    this.sampleCount++;
+    if (driftNs > this.maxDriftNs) {
+      this.maxDriftNs = driftNs;
+    }
+  }
+  /**
+   * Average schedule drift in milliseconds.
+   */
+  get averageDriftMs() {
+    if (this.sampleCount === 0) return 0;
+    return Number(this.totalDriftNs / BigInt(this.sampleCount)) / 1e6;
+  }
+  /**
+   * Maximum schedule drift in milliseconds.
+   */
+  get maxDriftMs() {
+    return Number(this.maxDriftNs) / 1e6;
+  }
+};
+
+export {
+  Histogram,
+  recordWithCorrection,
+  extractDistribution,
+  computeQueueDelay,
+  ArrivalScheduler
+};
+//# sourceMappingURL=chunk-7L4SENK7.js.map

package/dist/chunk-7L4SENK7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/stats/histogram.ts","../src/stats/co-corrector.ts","../src/core/scheduler.ts"],"sourcesContent":["export const GROWTH = 1.02;\r\nexport const BUCKETS = 1200; // 1.02^1200 us ≈ 21,114 seconds (~5.8 hours)\r\n\r\n/**\r\n * Fixed-Memory Log-Bucketed Histogram.\r\n *\r\n * Storing raw latency arrays creates O(N) memory usage and triggers GC pauses.\r\n * This histogram uses a fixed Uint32Array(1200) (~4.8 KB of memory forever).\r\n * Relative error is bounded by (GROWTH - 1) ≈ 2%.\r\n */\r\nexport class Histogram {\r\n  /** Fixed 4.8 KB bucket array of counts */\r\n  readonly counts = new Uint32Array(BUCKETS);\r\n  /** Total number of recorded samples */\r\n  total = 0;\r\n\r\n  private minVal = Infinity;\r\n  private maxVal = 0;\r\n  private sumUs = 0;\r\n\r\n  /**\r\n   * Calculate bucket index from latency in microseconds.\r\n   * O(1) mathematical mapping.\r\n   */\r\n  private idx(us: number): number {\r\n    if (us <= 1) return 0;\r\n    const bucket = Math.floor(Math.log(us) / Math.log(GROWTH));\r\n    return Math.min(BUCKETS - 1, Math.max(0, bucket));\r\n  }\r\n\r\n  /**\r\n   * Reconstruct microsecond value from bucket index.\r\n   */\r\n  private valFromIdx(i: number): number {\r\n    return Math.pow(GROWTH, i + 1);\r\n  }\r\n\r\n  /**\r\n   * Record a latency value in microseconds (us).\r\n   */\r\n  record(us: number): void {\r\n    const val = Math.max(0, us);\r\n    const i = this.idx(val);\r\n    this.counts[i]++;\r\n    this.total++;\r\n    this.sumUs += val;\r\n\r\n    if (val < this.minVal) this.minVal = val;\r\n    if (val > this.maxVal) this.maxVal = val;\r\n  }\r\n\r\n  /**\r\n   * Merge another histogram into this one.\r\n   * Merging is simple O(B) vector addition across the fixed bucket array.\r\n   */\r\n  merge(other: Histogram): void {\r\n    for (let i = 0; i < BUCKETS; i++) {\r\n      this.counts[i] += other.counts[i];\r\n    }\r\n    this.total += other.total;\r\n    this.sumUs += other.sumUs;\r\n    if (other.minVal < this.minVal) this.minVal = other.minVal;\r\n    if (other.maxVal > this.maxVal) this.maxVal = other.maxVal;\r\n  }\r\n\r\n  /**\r\n   * Calculate the given percentile (0..100) in microseconds (us).\r\n   */\r\n  percentile(p: number): number {\r\n    if (this.total === 0) return 0;\r\n    if (p <= 0) return this.min();\r\n    if (p >= 100) return this.max();\r\n\r\n    const target = Math.ceil((p / 100) * this.total);\r\n    let seen = 0;\r\n\r\n    for (let i = 0; i < BUCKETS; i++) {\r\n      seen += this.counts[i];\r\n      if (seen >= target) {\r\n        const val = this.valFromIdx(i);\r\n        return Math.min(Math.max(val, this.minVal), this.maxVal);\r\n      }\r\n    }\r\n\r\n    return this.max();\r\n  }\r\n\r\n  /**\r\n   * Return percentile in milliseconds (ms).\r\n   */\r\n  percentileMs(p: number): number {\r\n    return this.percentile(p) / 1000;\r\n  }\r\n\r\n  /**\r\n   * Minimum recorded latency in microseconds (us).\r\n   */\r\n  min(): number {\r\n    return this.total === 0 ? 0 : this.minVal;\r\n  }\r\n\r\n  /**\r\n   * Minimum recorded latency in milliseconds (ms).\r\n   */\r\n  minMs(): number {\r\n    return this.min() / 1000;\r\n  }\r\n\r\n  /**\r\n   * Maximum recorded latency in microseconds (us).\r\n   */\r\n  max(): number {\r\n    return this.total === 0 ? 0 : this.maxVal;\r\n  }\r\n\r\n  /**\r\n   * Maximum recorded latency in milliseconds (ms).\r\n   */\r\n  maxMs(): number {\r\n    return this.max() / 1000;\r\n  }\r\n\r\n  /**\r\n   * Mean (average) latency in microseconds (us).\r\n   */\r\n  mean(): number {\r\n    return this.total === 0 ? 0 : this.sumUs / this.total;\r\n  }\r\n\r\n  /**\r\n   * Mean (average) latency in milliseconds (ms).\r\n   */\r\n  meanMs(): number {\r\n    return this.mean() / 1000;\r\n  }\r\n\r\n  /**\r\n   * Reset all bucket counts and statistics.\r\n   */\r\n  reset(): void {\r\n    this.counts.fill(0);\r\n    this.total = 0;\r\n    this.sumUs = 0;\r\n    this.minVal = Infinity;\r\n    this.maxVal = 0;\r\n  }\r\n\r\n  /**\r\n   * Export raw snapshot data for inter-thread messaging (worker_threads).\r\n   */\r\n  toSnapshot(): { counts: Uint32Array; total: number; minVal: number; maxVal: number; sumUs: number } {\r\n    return {\r\n      counts: new Uint32Array(this.counts),\r\n      total: this.total,\r\n      minVal: this.minVal,\r\n      maxVal: this.maxVal,\r\n      sumUs: this.sumUs,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Restore or merge from a worker snapshot.\r\n   */\r\n  mergeSnapshot(snapshot: { counts: Uint32Array; total: number; minVal: number; maxVal: number; sumUs: number }): void {\r\n    for (let i = 0; i < BUCKETS; i++) {\r\n      this.counts[i] += snapshot.counts[i];\r\n    }\r\n    this.total += snapshot.total;\r\n    this.sumUs += snapshot.sumUs;\r\n    if (snapshot.minVal < this.minVal) this.minVal = snapshot.minVal;\r\n    if (snapshot.maxVal > this.maxVal) this.maxVal = snapshot.maxVal;\r\n  }\r\n}\r\n","import { Histogram } from \"./histogram.js\";\r\nimport type { LatencyDistribution } from \"../types.js\";\r\n\r\n/**\r\n * Gil Tene's Coordinated Omission Correction algorithm (from wrk2 / HdrHistogram).\r\n *\r\n * In load testing, when a request stalls or experiences high latency L exceeding\r\n * the expected inter-arrival interval I, all requests that would have arrived\r\n * behind it during that stall are omitted from the sample pool.\r\n *\r\n * This function injects the missing virtual samples (L - I, L - 2I, ...) into\r\n * the histogram, accurately penalizing high percentiles (p95, p99) to reflect\r\n * what real users experienced while the system was stalled.\r\n */\r\nexport function recordWithCorrection(\r\n  histogram: Histogram,\r\n  latencyUs: number,\r\n  expectedIntervalUs: number\r\n): number {\r\n  const primaryVal = Math.max(0, latencyUs);\r\n  histogram.record(primaryVal);\r\n\r\n  if (expectedIntervalUs <= 0 || primaryVal <= expectedIntervalUs) {\r\n    return 1;\r\n  }\r\n\r\n  let totalSamplesAdded = 1;\r\n  let virtualLatencyUs = primaryVal - expectedIntervalUs;\r\n\r\n  // Synthesize missing requests queued behind the stall\r\n  while (virtualLatencyUs > 0) {\r\n    histogram.record(virtualLatencyUs);\r\n    totalSamplesAdded++;\r\n    virtualLatencyUs -= expectedIntervalUs;\r\n  }\r\n\r\n  return totalSamplesAdded;\r\n}\r\n\r\n/**\r\n * Helper to extract formatted LatencyDistribution metrics from a Histogram.\r\n */\r\nexport function extractDistribution(h: Histogram): LatencyDistribution {\r\n  return {\r\n    p50: h.percentileMs(50),\r\n    p90: h.percentileMs(90),\r\n    p95: h.percentileMs(95),\r\n    p99: h.percentileMs(99),\r\n    min: h.minMs(),\r\n    max: h.maxMs(),\r\n    mean: h.meanMs(),\r\n  };\r\n}\r\n\r\n/**\r\n * Calculates the queue delay distribution by subtracting service time from response time.\r\n */\r\nexport function computeQueueDelay(\r\n  response: LatencyDistribution,\r\n  service: LatencyDistribution\r\n): LatencyDistribution {\r\n  return {\r\n    p50: Math.max(0, response.p50 - service.p50),\r\n    p90: Math.max(0, response.p90 - service.p90),\r\n    p95: Math.max(0, response.p95 - service.p95),\r\n    p99: Math.max(0, response.p99 - service.p99),\r\n    min: Math.max(0, response.min - service.min),\r\n    max: Math.max(0, response.max - service.max),\r\n    mean: Math.max(0, response.mean - service.mean),\r\n  };\r\n}\r\n","/**\r\n * High-precision arrival scheduler for open-model load testing.\r\n * Supports deterministic uniform intervals and stochastic Poisson arrival processes.\r\n */\r\nexport class ArrivalScheduler {\r\n  private readonly rate: number;\r\n  private readonly distribution: \"uniform\" | \"poisson\";\r\n  private readonly startNs: bigint;\r\n  private currentScheduledNs: bigint;\r\n  private totalDriftNs = 0n;\r\n  private sampleCount = 0;\r\n  private maxDriftNs = 0n;\r\n\r\n  constructor(rate: number, distribution: \"uniform\" | \"poisson\" = \"uniform\", startNs?: bigint) {\r\n    this.rate = Math.max(0.1, rate);\r\n    this.distribution = distribution;\r\n    this.startNs = startNs ?? process.hrtime.bigint();\r\n    this.currentScheduledNs = this.startNs;\r\n  }\r\n\r\n  /**\r\n   * Generates the next scheduled arrival timestamp (in nanoseconds).\r\n   */\r\n  nextArrivalNs(): bigint {\r\n    if (this.distribution === \"poisson\") {\r\n      // Poisson process: inter-arrival time is exponentially distributed\r\n      // Delta_t = -ln(U) / lambda\r\n      const u = Math.max(1e-10, 1 - Math.random());\r\n      const intervalSec = -Math.log(u) / this.rate;\r\n      const intervalNs = BigInt(Math.max(1, Math.floor(intervalSec * 1_000_000_000)));\r\n      this.currentScheduledNs += intervalNs;\r\n    } else {\r\n      // Uniform fixed arrival interval: Delta_t = 1 / lambda\r\n      const intervalNs = BigInt(Math.max(1, Math.floor(1_000_000_000 / this.rate)));\r\n      this.currentScheduledNs += intervalNs;\r\n    }\r\n\r\n    return this.currentScheduledNs;\r\n  }\r\n\r\n  /**\r\n   * High-resolution pause until the target timestamp is reached.\r\n   * Uses setTimeout for long waits and micro-spinning for sub-millisecond precision.\r\n   */\r\n  async waitUntil(targetNs: bigint): Promise<void> {\r\n    const now = process.hrtime.bigint();\r\n    if (now >= targetNs) {\r\n      this.recordDrift(now - targetNs);\r\n      return;\r\n    }\r\n\r\n    const diffNs = targetNs - now;\r\n    const diffMs = Number(diffNs) / 1_000_000;\r\n\r\n    // Yield event loop for sleeps longer than 2ms\r\n    if (diffMs > 2) {\r\n      await new Promise((resolve) => setTimeout(resolve, Math.floor(diffMs - 1)));\r\n    }\r\n\r\n    // Micro-spin for remaining sub-millisecond precision\r\n    while (process.hrtime.bigint() < targetNs) {\r\n      // Yield slightly if still noticeably ahead\r\n      if (Number(targetNs - process.hrtime.bigint()) > 500_000) {\r\n        await new Promise((r) => setImmediate(r));\r\n      }\r\n    }\r\n\r\n    const actual = process.hrtime.bigint();\r\n    this.recordDrift(actual > targetNs ? actual - targetNs : 0n);\r\n  }\r\n\r\n  private recordDrift(driftNs: bigint): void {\r\n    this.totalDriftNs += driftNs;\r\n    this.sampleCount++;\r\n    if (driftNs > this.maxDriftNs) {\r\n      this.maxDriftNs = driftNs;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Average schedule drift in milliseconds.\r\n   */\r\n  get averageDriftMs(): number {\r\n    if (this.sampleCount === 0) return 0;\r\n    return Number(this.totalDriftNs / BigInt(this.sampleCount)) / 1_000_000;\r\n  }\r\n\r\n  /**\r\n   * Maximum schedule drift in milliseconds.\r\n   */\r\n  get maxDriftMs(): number {\r\n    return Number(this.maxDriftNs) / 1_000_000;\r\n  }\r\n}\r\n"],"mappings":"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","names":[]}