fboxrec 0.1.0

package/dist/chunk-HCJF2ASP.mjs

@@ -0,0 +1,2194 @@
+// src/index.ts
+import { isMainThread } from "worker_threads";
+import * as fs6 from "fs";
+import * as path7 from "path";
+import * as zlib from "zlib";
+
+// src/config.ts
+import * as path from "path";
+var DEFAULTS = {
+  bufferMb: 64,
+  dir: ".flightbox",
+  slowRequestMs: 5e3,
+  cooldownMs: 6e4,
+  heapPct: 0.9,
+  stallMs: 1e3,
+  shedLagMs: 50,
+  maxStageMb: 500,
+  minDiskFreePct: 5,
+  viewerOrigin: "https://viewer.flightbox.dev"
+};
+function envNumber(name) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : void 0;
+}
+function envBool(name) {
+  return process.env[name] === "1" || process.env[name] === "true";
+}
+function envS3Sink() {
+  const bucket = process.env.FLIGHTBOX_S3_BUCKET;
+  if (!bucket) return null;
+  return {
+    type: "s3",
+    bucket,
+    prefix: process.env.FLIGHTBOX_S3_PREFIX ?? "",
+    endpoint: process.env.FLIGHTBOX_S3_ENDPOINT,
+    region: process.env.FLIGHTBOX_S3_REGION,
+    presign: { enabled: true }
+  };
+}
+function validateSink(sink) {
+  switch (sink.type) {
+    case "s3": {
+      if (!sink.bucket || typeof sink.bucket !== "string") {
+        throw new Error('flightbox: s3 sink requires a non-empty "bucket"');
+      }
+      if (sink.endpoint !== void 0 && !/^https?:\/\//.test(sink.endpoint)) {
+        throw new Error(`flightbox: s3 sink "endpoint" must be an http(s) URL, got ${sink.endpoint}`);
+      }
+      if (sink.prefix !== void 0 && typeof sink.prefix !== "string") {
+        throw new Error('flightbox: s3 sink "prefix" must be a string');
+      }
+      const hrs = sink.presign?.expiresHours;
+      if (hrs !== void 0 && (!Number.isFinite(hrs) || hrs <= 0 || hrs > 168)) {
+        throw new Error(`flightbox: s3 presign.expiresHours must be in (0, 168], got ${hrs}`);
+      }
+      break;
+    }
+    case "http": {
+      if (!/^https?:\/\//.test(sink.url ?? "")) {
+        throw new Error(`flightbox: http sink "url" must be an http(s) URL, got ${sink.url}`);
+      }
+      break;
+    }
+    case "disk": {
+      if (!sink.dir || typeof sink.dir !== "string") {
+        throw new Error('flightbox: disk sink requires a non-empty "dir"');
+      }
+      if (sink.maxMb !== void 0 && (!Number.isFinite(sink.maxMb) || sink.maxMb < 1)) {
+        throw new Error(`flightbox: disk sink "maxMb" must be >= 1, got ${sink.maxMb}`);
+      }
+      break;
+    }
+    default:
+      throw new Error(`flightbox: unknown sink type "${sink.type}"`);
+  }
+}
+function resolveConfig(user = {}) {
+  const bufferMb = envNumber("FLIGHTBOX_BUFFER_MB") ?? user.bufferMb ?? DEFAULTS.bufferMb;
+  const dir = process.env.FLIGHTBOX_DIR || user.dir || DEFAULTS.dir;
+  const service = process.env.FLIGHTBOX_SERVICE || user.service || path.basename(process.cwd());
+  const slowRequestMs = envNumber("FLIGHTBOX_TRIGGER_SLOW_MS") ?? user.triggers?.slowRequestMs ?? DEFAULTS.slowRequestMs;
+  const cooldownMs = user.triggers?.cooldownMs ?? DEFAULTS.cooldownMs;
+  const heapPct = envNumber("FLIGHTBOX_TRIGGER_HEAP_PCT") ?? user.triggers?.heapPct ?? DEFAULTS.heapPct;
+  const stallMs = envNumber("FLIGHTBOX_TRIGGER_STALL_MS") ?? user.triggers?.stallMs ?? DEFAULTS.stallMs;
+  const shedLagMs = envNumber("FLIGHTBOX_SHED_LAG_MS") ?? user.shedding?.shedLagMs ?? DEFAULTS.shedLagMs;
+  const maxStageMb = envNumber("FLIGHTBOX_MAX_STAGE_MB") ?? user.staging?.maxStageMb ?? DEFAULTS.maxStageMb;
+  const minDiskFreePct = user.staging?.minDiskFreePct ?? DEFAULTS.minDiskFreePct;
+  if (!Number.isFinite(bufferMb) || bufferMb < 1 || bufferMb > 4096) {
+    throw new RangeError(`flightbox: bufferMb must be between 1 and 4096, got ${bufferMb}`);
+  }
+  if (!Number.isFinite(slowRequestMs) || slowRequestMs < 50) {
+    throw new RangeError(`flightbox: triggers.slowRequestMs must be >= 50, got ${slowRequestMs}`);
+  }
+  if (!Number.isFinite(cooldownMs) || cooldownMs < 0) {
+    throw new RangeError(`flightbox: triggers.cooldownMs must be >= 0, got ${cooldownMs}`);
+  }
+  if (!Number.isFinite(heapPct) || heapPct <= 0 || heapPct >= 1) {
+    throw new RangeError(`flightbox: triggers.heapPct must be in (0,1), got ${heapPct}`);
+  }
+  if (!Number.isFinite(stallMs) || stallMs < 50) {
+    throw new RangeError(`flightbox: triggers.stallMs must be >= 50, got ${stallMs}`);
+  }
+  if (!Number.isFinite(shedLagMs) || shedLagMs < 1) {
+    throw new RangeError(`flightbox: shedding.shedLagMs must be >= 1, got ${shedLagMs}`);
+  }
+  if (!Number.isFinite(maxStageMb) || maxStageMb < 1) {
+    throw new RangeError(`flightbox: staging.maxStageMb must be >= 1, got ${maxStageMb}`);
+  }
+  if (!Number.isFinite(minDiskFreePct) || minDiskFreePct < 0 || minDiskFreePct > 50) {
+    throw new RangeError(`flightbox: staging.minDiskFreePct must be 0-50, got ${minDiskFreePct}`);
+  }
+  const sinks = [...user.sinks ?? []];
+  const s3FromEnv = envS3Sink();
+  if (s3FromEnv && !sinks.some((s) => s.type === "s3")) sinks.push(s3FromEnv);
+  sinks.forEach(validateSink);
+  return {
+    service,
+    bufferMb,
+    dir: path.resolve(dir),
+    triggers: { slowRequestMs, cooldownMs, heapPct, stallMs },
+    staging: { maxStageMb, minDiskFreePct },
+    shedding: { shedLagMs },
+    token: process.env.FLIGHTBOX_TOKEN || user.token,
+    viewerOrigin: process.env.FLIGHTBOX_VIEWER_ORIGIN || user.viewerOrigin || DEFAULTS.viewerOrigin,
+    sinks,
+    allowWorkerThreads: envBool("FLIGHTBOX_ALLOW_WORKER_THREADS") || (user.allowWorkerThreads ?? false),
+    log: user.log ?? ((msg) => process.stderr.write(`flightbox: ${msg}
+`))
+  };
+}
+
+// src/clock.ts
+var anchor = null;
+function anchorClock() {
+  anchor = { wallMs: Date.now(), monoNs: process.hrtime.bigint() };
+  return anchor;
+}
+function getAnchor() {
+  if (anchor === null) anchor = anchorClock();
+  return anchor;
+}
+function nowMono() {
+  return process.hrtime.bigint();
+}
+
+// src/ring-buffer.ts
+var LEN_BYTES = 4;
+var WRAP_MARKER = 4294967295;
+var RingBuffer = class _RingBuffer {
+  capacity;
+  buf;
+  writePos = 0;
+  /** Offset of the oldest valid record. Meaningless when count === 0. */
+  oldest = 0;
+  count = 0;
+  droppedCount = 0;
+  constructor(capacityBytes) {
+    if (!Number.isInteger(capacityBytes) || capacityBytes < 16) {
+      throw new RangeError(`ring buffer capacity must be an integer >= 16 bytes, got ${capacityBytes}`);
+    }
+    this.capacity = capacityBytes;
+    this.buf = Buffer.allocUnsafe(capacityBytes);
+  }
+  /** Number of records currently held. */
+  get size() {
+    return this.count;
+  }
+  /** Records rejected because they exceed total capacity. */
+  get dropped() {
+    return this.droppedCount;
+  }
+  /**
+   * Appends one record. The optional second part lets the hot path write
+   * header + body as one frame without concatenating them first (ADR 015).
+   */
+  write(payload, payload2) {
+    const recordLen = payload.length + (payload2 !== void 0 ? payload2.length : 0);
+    const needed = LEN_BYTES + recordLen;
+    if (needed > this.capacity) {
+      this.droppedCount++;
+      return false;
+    }
+    if (this.writePos + needed > this.capacity) {
+      this.evictRange(this.writePos, this.capacity);
+      if (this.capacity - this.writePos >= LEN_BYTES) {
+        this.buf.writeUInt32LE(WRAP_MARKER, this.writePos);
+      }
+      this.writePos = 0;
+    }
+    this.evictRange(this.writePos, this.writePos + needed);
+    if (this.count === 0) this.oldest = this.writePos;
+    this.buf.writeUInt32LE(recordLen, this.writePos);
+    this.buf.set(payload, this.writePos + LEN_BYTES);
+    if (payload2 !== void 0) {
+      this.buf.set(payload2, this.writePos + LEN_BYTES + payload.length);
+    }
+    this.writePos += needed;
+    this.count++;
+    return true;
+  }
+  /**
+   * Copies all records out in chronological order. Recording can continue
+   * afterwards; the returned buffers are independent copies.
+   */
+  snapshot() {
+    return _RingBuffer.readRecords(this.buf, this.capacity, this.oldest, this.count);
+  }
+  /**
+   * ADR 009 panic path ONLY: the live underlying buffer and pointers, for a
+   * raw zero-allocation dump. Everything else must go through snapshot().
+   */
+  get rawState() {
+    return { buf: this.buf, oldest: this.oldest, count: this.count };
+  }
+  /**
+   * Frame-walks a ring image. Shared by live snapshots and panic-file
+   * recovery — the latter reads bytes from a crashed process, so lengths are
+   * bounds-checked and the walk bails on the first corrupt frame.
+   */
+  static readRecords(buf, capacity, oldest, count) {
+    const out = [];
+    let pos = oldest;
+    for (let i = 0; i < count; i++) {
+      if (pos < 0 || pos > capacity) break;
+      if (capacity - pos < LEN_BYTES || buf.readUInt32LE(pos) === WRAP_MARKER) pos = 0;
+      const len = buf.readUInt32LE(pos);
+      if (len > capacity - pos - LEN_BYTES) break;
+      out.push(Buffer.from(buf.subarray(pos + LEN_BYTES, pos + LEN_BYTES + len)));
+      pos += LEN_BYTES + len;
+    }
+    return out;
+  }
+  clear() {
+    this.writePos = 0;
+    this.oldest = 0;
+    this.count = 0;
+  }
+  /** Skip implicit (tail gap < 4B) and explicit wrap markers. */
+  normalize(pos) {
+    if (this.capacity - pos < LEN_BYTES || this.buf.readUInt32LE(pos) === WRAP_MARKER) {
+      return 0;
+    }
+    return pos;
+  }
+  /** Evict oldest records while they start inside [start, end). */
+  evictRange(start2, end) {
+    while (this.count > 0) {
+      this.oldest = this.normalize(this.oldest);
+      if (this.oldest < start2 || this.oldest >= end) return;
+      const len = this.buf.readUInt32LE(this.oldest);
+      this.oldest += LEN_BYTES + len;
+      this.count--;
+    }
+  }
+};
+
+// src/recorder.ts
+import { pack as pack2 } from "msgpackr";
+
+// src/encoder.ts
+import { pack, unpack } from "msgpackr";
+var HEADER_SIZE = 29;
+var EVENT_TYPE_NAMES = {
+  [1 /* HttpServerStart */]: "http.server.start",
+  [2 /* HttpServerEnd */]: "http.server.end",
+  [3 /* HttpClientStart */]: "http.client.start",
+  [4 /* HttpClientEnd */]: "http.client.end",
+  [5 /* PgQueryStart */]: "pg.query.start",
+  [6 /* PgQueryEnd */]: "pg.query.end",
+  [7 /* PgPoolWait */]: "pg.pool.wait",
+  [8 /* Log */]: "log",
+  [9 /* Vitals */]: "vitals",
+  [10 /* Trigger */]: "trigger",
+  [11 /* Custom */]: "custom"
+};
+var LIMITS = {
+  path: 512,
+  query: 2048,
+  log: 1024
+};
+function truncate(s, max) {
+  if (s === void 0 || s === null) return void 0;
+  return s.length > max ? s.slice(0, max) : s;
+}
+function encodeHeaderInto(target, seq, tMonoNs, type, requestId, spanId) {
+  target.writeUInt32LE(seq >>> 0, 0);
+  target.writeBigUInt64LE(tMonoNs, 4);
+  target.writeUInt8(type & 255, 12);
+  target.writeBigUInt64LE(requestId, 13);
+  target.writeBigUInt64LE(spanId, 21);
+}
+function decodeEvent(buf) {
+  if (buf.length < HEADER_SIZE) {
+    throw new RangeError(`event record too short: ${buf.length} bytes`);
+  }
+  return {
+    header: {
+      seq: buf.readUInt32LE(0),
+      tMonoNs: buf.readBigUInt64LE(4),
+      type: buf.readUInt8(12),
+      requestId: buf.readBigUInt64LE(13),
+      spanId: buf.readBigUInt64LE(21)
+    },
+    payload: unpack(buf.subarray(HEADER_SIZE))
+  };
+}
+
+// src/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var requestStorage = new AsyncLocalStorage();
+var nextRequestId = 1n;
+var nextSpanId = 1n;
+var U64_MASK = 0xffffffffffffffffn;
+function newRequestId() {
+  const id = nextRequestId;
+  nextRequestId = nextRequestId + 1n & U64_MASK;
+  if (nextRequestId === 0n) nextRequestId = 1n;
+  return id;
+}
+function newSpanId() {
+  const id = nextSpanId;
+  nextSpanId = nextSpanId + 1n & U64_MASK;
+  if (nextSpanId === 0n) nextSpanId = 1n;
+  return id;
+}
+function currentRequestId() {
+  return requestStorage.getStore()?.requestId ?? 0n;
+}
+
+// src/recorder.ts
+var scratchHeader = Buffer.allocUnsafe(HEADER_SIZE);
+var MAX_EVENT_PAYLOAD_BYTES = 64 * 1024;
+var Recorder = class {
+  constructor(ring) {
+    this.ring = ring;
+  }
+  ring;
+  armed = false;
+  seq = 0;
+  record(type, payload, opts) {
+    if (!this.armed) return;
+    try {
+      encodeHeaderInto(
+        scratchHeader,
+        this.seq++ >>> 0,
+        opts?.tMonoNs ?? nowMono(),
+        type,
+        opts?.requestId ?? currentRequestId(),
+        opts?.spanId ?? 0n
+      );
+      let body = pack2(payload);
+      if (body.length > MAX_EVENT_PAYLOAD_BYTES) {
+        body = pack2({ __truncated: true, originalBytes: body.length });
+      }
+      this.ring.write(scratchHeader, body);
+    } catch {
+    }
+  }
+  /**
+   * ADR 005 — zero-lock freeze: swap in a fresh ring for active writes and
+   * return the frozen one. Incoming traffic keeps recording into the new
+   * buffer while the frozen segment is serialized; the frozen bytes can
+   * never be overwritten mid-dump.
+   *
+   * `replacementBytes` lets memory-pressure dumps swap in a SMALL emergency
+   * ring instead of another full-size allocation — allocating 64MB (or up
+   * to 4GB) at the exact moment the heap trigger fired would deepen the
+   * incident being recorded. The next normal-path dump restores full size.
+   */
+  freezeAndSwap(replacementBytes) {
+    const frozen = this.ring;
+    this.ring = new RingBuffer(
+      Math.min(replacementBytes ?? frozen.capacity, frozen.capacity)
+    );
+    return frozen;
+  }
+  /** Decode a chronological copy of the active buffer. Recording continues. */
+  snapshot() {
+    return decodeRing(this.ring);
+  }
+  get eventCount() {
+    return this.ring.size;
+  }
+  /** ADR 009 panic path ONLY — raw access to the live ring. */
+  get activeRing() {
+    return this.ring;
+  }
+};
+function decodeRing(ring) {
+  const out = [];
+  for (const rec of ring.snapshot()) {
+    try {
+      out.push(decodeEvent(rec));
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/load-shedding.ts
+var active = false;
+function isShedding() {
+  return active;
+}
+function setShedding(on) {
+  active = on;
+}
+
+// src/dump/stage.ts
+import * as fs from "fs";
+import * as path2 from "path";
+var DiskFullError = class extends Error {
+  constructor(freePct, minFreePct) {
+    super(
+      `disk has ${freePct.toFixed(1)}% free, below the ${minFreePct}% safety floor`
+    );
+    this.name = "DiskFullError";
+  }
+};
+var PID_DIR_RE = /^pid-(\d+)$/;
+var CLAIMED_DIR_RE = /^claimed-(\d+)-(.+)$/;
+var Staging = class {
+  constructor(baseDir, limits, log = () => {
+  }) {
+    this.limits = limits;
+    this.log = log;
+    this.baseStagingDir = path2.join(baseDir, "staging");
+    this.stagingDir = path2.join(this.baseStagingDir, `pid-${process.pid}`);
+    this.deliveredDir = path2.join(baseDir, "delivered");
+    fs.mkdirSync(this.stagingDir, { recursive: true });
+    fs.mkdirSync(this.deliveredDir, { recursive: true });
+  }
+  limits;
+  log;
+  /** Shared root: <dir>/staging/ */
+  baseStagingDir;
+  /** This process's isolated dir: <dir>/staging/pid-<pid>/ (ADR 010). */
+  stagingDir;
+  deliveredDir;
+  /**
+   * Synchronous, crash-safe write: tmp file + fsync + rename (+ best-effort
+   * parent-dir fsync on POSIX), so staging never holds a torn .fbox and a
+   * power loss right after return cannot un-persist it. Throws
+   * DiskFullError when the disk is critically full — the caller must
+   * disable the agent (ADR 006) — and rejects any single dump larger than
+   * the quota outright: "evict everything, then write the oversized file
+   * anyway" would make the cap a fiction.
+   */
+  stageSync(fileName, data) {
+    const maxBytes = this.limits.maxStageMb * 1024 * 1024;
+    if (data.length > maxBytes) {
+      throw new Error(
+        `dump is ${(data.length / 1048576).toFixed(1)}MB, larger than the ${this.limits.maxStageMb}MB staging quota \u2014 refusing to stage it`
+      );
+    }
+    const freePct = this.diskFreePct();
+    if (freePct !== null && freePct < this.limits.minDiskFreePct) {
+      throw new DiskFullError(freePct, this.limits.minDiskFreePct);
+    }
+    this.evictOverQuota(data.length);
+    const finalPath = path2.join(this.stagingDir, fileName);
+    const tmpPath = finalPath + ".part";
+    const fd = fs.openSync(tmpPath, "w");
+    try {
+      fs.writeSync(fd, data);
+      fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.renameSync(tmpPath, finalPath);
+    try {
+      const dirFd = fs.openSync(this.stagingDir, "r");
+      fs.fsyncSync(dirFd);
+      fs.closeSync(dirFd);
+    } catch {
+    }
+    return finalPath;
+  }
+  /** Own staged .fbox files, oldest first (names embed timestamps). */
+  listStagedSync() {
+    return this.listOwn(".fbox");
+  }
+  /** Own raw panic dumps awaiting conversion (ADR 009). */
+  listPanicSync() {
+    return this.listOwn(".fboxpanic");
+  }
+  /**
+   * Move a staged file to delivered/ after successful sink delivery.
+   * delivered/ shares the ADR 006 quota — local retention must not outlive
+   * the disk either.
+   */
+  markDeliveredSync(filePath) {
+    let incoming = 0;
+    try {
+      incoming = fs.statSync(filePath).size;
+    } catch {
+    }
+    this.evictFilesOverQuota(this.listDir(this.deliveredDir, ".fbox"), incoming);
+    const dest = path2.join(this.deliveredDir, path2.basename(filePath));
+    fs.renameSync(filePath, dest);
+    return dest;
+  }
+  /**
+   * ADR 010 adoption pass: absorb staging dirs left by DEAD sibling
+   * processes. renameSync is the atomicity lock — when several new workers
+   * race for the same orphan, exactly one rename succeeds; losers get
+   * ENOENT and move on. Also re-adopts `claimed-*` dirs whose claimant died
+   * mid-adoption (audit M4) — without this, a crash between the claim
+   * rename and the file moves would strand incidents invisibly forever.
+   * Returns how many files were adopted.
+   *
+   * Known limitation (audit L2): PID reuse. If a dead worker's pid was
+   * recycled by an unrelated live process, its dir looks "alive" and waits
+   * until that process exits. Solving this needs process identity beyond
+   * the pid (start-time comparison), which has no portable API — accepted
+   * for v0.1; the files are preserved, only delayed.
+   */
+  claimOrphanedSync() {
+    let adopted = 0;
+    let entries;
+    try {
+      entries = fs.readdirSync(this.baseStagingDir);
+    } catch {
+      return 0;
+    }
+    for (const entry of entries) {
+      let ownerPid;
+      let originalName = entry;
+      const orphan = PID_DIR_RE.exec(entry);
+      const halfClaimed = orphan ? null : CLAIMED_DIR_RE.exec(entry);
+      if (orphan) {
+        ownerPid = Number(orphan[1]);
+      } else if (halfClaimed) {
+        ownerPid = Number(halfClaimed[1]);
+        originalName = halfClaimed[2];
+      } else {
+        continue;
+      }
+      if (ownerPid === process.pid || isProcessAlive(ownerPid)) continue;
+      const orphanDir = path2.join(this.baseStagingDir, entry);
+      const claimedDir = path2.join(this.baseStagingDir, `claimed-${process.pid}-${originalName}`);
+      try {
+        fs.renameSync(orphanDir, claimedDir);
+      } catch {
+        continue;
+      }
+      try {
+        for (const file of fs.readdirSync(claimedDir)) {
+          if (!file.endsWith(".fbox") && !file.endsWith(".fboxpanic")) {
+            try {
+              fs.unlinkSync(path2.join(claimedDir, file));
+            } catch {
+            }
+            continue;
+          }
+          try {
+            fs.renameSync(path2.join(claimedDir, file), path2.join(this.stagingDir, file));
+            adopted++;
+          } catch {
+          }
+        }
+        fs.rmdirSync(claimedDir);
+      } catch {
+      }
+    }
+    if (adopted > 0) {
+      this.log(`adopted ${adopted} file(s) from dead worker staging dirs`);
+    }
+    return adopted;
+  }
+  listOwn(ext) {
+    return this.listDir(this.stagingDir, ext);
+  }
+  listDir(dir, ext) {
+    try {
+      return fs.readdirSync(dir).filter((f) => f.endsWith(ext)).sort().map((f) => path2.join(dir, f));
+    } catch {
+      return [];
+    }
+  }
+  /** null = cannot determine (treat as healthy rather than disable the agent). */
+  diskFreePct() {
+    const statfsSync2 = fs.statfsSync;
+    if (typeof statfsSync2 !== "function") return null;
+    try {
+      const s = statfsSync2(this.stagingDir);
+      const blocks = Number(s.blocks);
+      if (!Number.isFinite(blocks) || blocks <= 0) return null;
+      return Number(s.bavail) / blocks * 100;
+    } catch {
+      return null;
+    }
+  }
+  /** ADR 006 FIFO eviction: silently drop oldest staged dumps to fit the quota. */
+  evictOverQuota(incomingBytes) {
+    this.evictFilesOverQuota(this.listStagedSync(), incomingBytes);
+  }
+  evictFilesOverQuota(candidates, incomingBytes) {
+    const maxBytes = this.limits.maxStageMb * 1024 * 1024;
+    const files = [];
+    let total = incomingBytes;
+    for (const file of candidates) {
+      try {
+        const size = fs.statSync(file).size;
+        files.push({ file, size });
+        total += size;
+      } catch {
+      }
+    }
+    for (const { file, size } of files) {
+      if (total <= maxBytes) break;
+      try {
+        fs.unlinkSync(file);
+        total -= size;
+        this.log(`staging quota (${this.limits.maxStageMb}MB) exceeded \u2014 evicted oldest: ${path2.basename(file)}`);
+      } catch {
+      }
+    }
+  }
+};
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function recoverOnBoot(staging, log) {
+  staging.claimOrphanedSync();
+  const files = staging.listStagedSync();
+  if (files.length > 0) {
+    log(
+      `found ${files.length} unsent incident(s) from a previous run in ${staging.stagingDir}`
+    );
+  }
+  return files;
+}
+
+// src/dump/panic.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+
+// src/dump/serializer.ts
+import { gzipSync } from "zlib";
+
+// ../format/src/types.ts
+var FORMAT_VERSION = 1;
+
+// ../format/src/parse.ts
+var MAX_DECOMPRESSED_BYTES = 1024 * 1024 * 1024;
+
+// src/dump/serializer.ts
+var FLIGHTBOX_VERSION = "0.1.0";
+var DUMP_GZIP_LEVEL = 1;
+var dumpCounter = 0;
+function buildIncident(opts) {
+  const anchor2 = opts.anchor ?? getAnchor();
+  const events = opts.events.map((e) => ({
+    seq: e.header.seq,
+    wallMs: anchor2.wallMs + Number(e.header.tMonoNs - anchor2.monoNs) / 1e6,
+    tMonoNs: e.header.tMonoNs.toString(),
+    type: EVENT_TYPE_NAMES[e.header.type] ?? `unknown.${e.header.type}`,
+    // ADR 004: context-less events are "orphan", never an error.
+    requestId: e.header.requestId === 0n ? "orphan" : e.header.requestId.toString(),
+    spanId: e.header.spanId.toString(),
+    data: e.payload
+  }));
+  const first = events[0];
+  const last = events[events.length - 1];
+  const windowMs = first && last ? last.wallMs - first.wallMs : 0;
+  const meta = {
+    service: opts.service,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    wallAnchor: { wallMs: anchor2.wallMs, monoNs: anchor2.monoNs.toString() },
+    trigger: opts.trigger,
+    eventCount: events.length,
+    windowMs,
+    flightboxVersion: FLIGHTBOX_VERSION
+  };
+  const incident = { formatVersion: FORMAT_VERSION, meta, events };
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const fileName = `incident-${stamp}-p${process.pid}-${(dumpCounter++).toString(36)}.fbox`;
+  return {
+    fileName,
+    json: JSON.stringify(incident),
+    meta,
+    eventCount: events.length,
+    windowMs
+  };
+}
+function serializeIncident(opts) {
+  const prepared = buildIncident(opts);
+  return {
+    fileName: prepared.fileName,
+    data: gzipSync(prepared.json, { level: DUMP_GZIP_LEVEL }),
+    meta: prepared.meta,
+    eventCount: prepared.eventCount,
+    windowMs: prepared.windowMs
+  };
+}
+
+// src/dump/panic.ts
+var MAGIC = Buffer.from("FBOXPANC", "ascii");
+var PANIC_VERSION = 1;
+var PANIC_HEADER_LEN = 44;
+var PanicWriter = class {
+  fd = null;
+  /** Preallocated so panic-time writes allocate (nearly) nothing. */
+  header = Buffer.alloc(PANIC_HEADER_LEN);
+  filePath;
+  constructor(stagingDir) {
+    this.filePath = path3.join(stagingDir, `panic-${process.pid}.fboxpanic`);
+  }
+  /** Preopen the fd while memory is plentiful. Failure is non-fatal. */
+  arm() {
+    try {
+      this.fd = fs2.openSync(this.filePath, "w");
+    } catch {
+      this.fd = null;
+    }
+  }
+  /**
+   * The panic dump: no gzip, no decode, no envelope — raw ring bytes onto
+   * the preopened fd. Safe to call with V8 near the heap limit.
+   */
+  writeSync(ring) {
+    if (this.fd === null) return false;
+    try {
+      const state = ring.rawState;
+      const anchor2 = getAnchor();
+      MAGIC.copy(this.header, 0);
+      this.header.writeUInt32LE(PANIC_VERSION, 8);
+      this.header.writeUInt32LE(ring.capacity, 12);
+      this.header.writeUInt32LE(state.oldest, 16);
+      this.header.writeUInt32LE(state.count, 20);
+      this.header.writeDoubleLE(anchor2.wallMs, 24);
+      this.header.writeBigUInt64LE(anchor2.monoNs, 32);
+      fs2.writeSync(this.fd, this.header, 0, PANIC_HEADER_LEN, 0);
+      fs2.writeSync(this.fd, state.buf, 0, state.buf.length, PANIC_HEADER_LEN);
+      fs2.fsyncSync(this.fd);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Clean shutdown: close the fd and sweep the empty placeholder. */
+  disarm() {
+    try {
+      if (this.fd !== null) fs2.closeSync(this.fd);
+      this.fd = null;
+      if (fs2.existsSync(this.filePath) && fs2.statSync(this.filePath).size === 0) {
+        fs2.unlinkSync(this.filePath);
+      }
+    } catch {
+      this.fd = null;
+    }
+  }
+};
+function parsePanicFile(raw) {
+  if (raw.length < PANIC_HEADER_LEN || !raw.subarray(0, 8).equals(MAGIC)) return null;
+  if (raw.readUInt32LE(8) !== PANIC_VERSION) return null;
+  const capacity = raw.readUInt32LE(12);
+  const oldest = raw.readUInt32LE(16);
+  const count = raw.readUInt32LE(20);
+  const wallMs = raw.readDoubleLE(24);
+  const monoNs = raw.readBigUInt64LE(32);
+  const body = raw.subarray(PANIC_HEADER_LEN);
+  if (body.length !== capacity || oldest >= capacity) return null;
+  const events = [];
+  for (const rec of RingBuffer.readRecords(body, capacity, oldest, count)) {
+    try {
+      events.push(decodeEvent(rec));
+    } catch {
+    }
+  }
+  events.sort(
+    (a, b) => a.header.tMonoNs < b.header.tMonoNs ? -1 : a.header.tMonoNs > b.header.tMonoNs ? 1 : 0
+  );
+  return { anchor: { wallMs, monoNs }, events };
+}
+function recoverPanicFiles(staging, service, log) {
+  let recovered = 0;
+  for (const file of staging.listPanicSync()) {
+    try {
+      if (fs2.statSync(file).size < PANIC_HEADER_LEN) {
+        fs2.unlinkSync(file);
+        continue;
+      }
+      const parsed = parsePanicFile(fs2.readFileSync(file));
+      if (parsed === null) {
+        fs2.renameSync(file, file + ".corrupt");
+        log(`panic dump ${path3.basename(file)} is unparseable \u2014 kept as .corrupt`);
+        continue;
+      }
+      const { fileName, data, eventCount } = serializeIncident({
+        service,
+        trigger: { type: "panic", reason: "recovered from crash-time panic dump" },
+        events: parsed.events,
+        anchor: parsed.anchor
+      });
+      staging.stageSync(fileName, data);
+      fs2.unlinkSync(file);
+      recovered++;
+      log(`recovered panic dump \u2192 ${fileName} (${eventCount} events)`);
+    } catch (err) {
+      log(`panic recovery failed for ${path3.basename(file)}: ${err.message}`);
+    }
+  }
+  return recovered;
+}
+
+// src/dump/snapshot.ts
+function takeFrozenSnapshot(recorder, replacementBytes) {
+  return decodeRing(recorder.freezeAndSwap(replacementBytes));
+}
+
+// src/dump/sinks/disk.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+function createDiskSink(cfg) {
+  const maxBytes = (cfg.maxMb ?? 500) * 1024 * 1024;
+  return {
+    name: "disk",
+    async deliver(filePath) {
+      const dir = path4.resolve(cfg.dir);
+      await fs3.promises.mkdir(dir, { recursive: true });
+      const dest = path4.join(dir, path4.basename(filePath));
+      await fs3.promises.copyFile(filePath, dest);
+      evictOverQuota(dir, maxBytes);
+      return { ok: true, location: dest };
+    }
+  };
+}
+function evictOverQuota(dir, maxBytes) {
+  try {
+    const files = fs3.readdirSync(dir).filter((f) => f.endsWith(".fbox")).sort().map((f) => path4.join(dir, f));
+    let total = 0;
+    const sized = files.map((file) => {
+      const size = fs3.statSync(file).size;
+      total += size;
+      return { file, size };
+    });
+    for (const { file, size } of sized) {
+      if (total <= maxBytes) break;
+      fs3.unlinkSync(file);
+      total -= size;
+    }
+  } catch {
+  }
+}
+
+// src/dump/sinks/s3.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+
+// src/dump/sinks/sigv4.ts
+import { createHash, createHmac } from "crypto";
+function sha256Hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function hmac(key, data) {
+  return createHmac("sha256", key).update(data, "utf8").digest();
+}
+function uriEncode(str, encodeSlash) {
+  let out = "";
+  for (const ch of str) {
+    if (/[A-Za-z0-9\-._~]/.test(ch) || ch === "/" && !encodeSlash) {
+      out += ch;
+    } else {
+      for (const byte of Buffer.from(ch, "utf8")) {
+        out += "%" + byte.toString(16).toUpperCase().padStart(2, "0");
+      }
+    }
+  }
+  return out;
+}
+function timestamps(now) {
+  const iso = now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
+  return { amzDate: iso, dateStamp: iso.slice(0, 8) };
+}
+function canonicalUri(url) {
+  return url.pathname.split("/").map((seg) => uriEncode(safeDecode(seg), true)).join("/") || "/";
+}
+function safeDecode(seg) {
+  try {
+    return decodeURIComponent(seg);
+  } catch {
+    return seg;
+  }
+}
+function byCodePoint(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function canonicalQuery(params) {
+  return params.map(([k, v]) => [uriEncode(k, true), uriEncode(v, true)]).sort((a, b) => a[0] === b[0] ? byCodePoint(a[1], b[1]) : byCodePoint(a[0], b[0])).map(([k, v]) => `${k}=${v}`).join("&");
+}
+function signingKey(secret, dateStamp, region, service) {
+  return hmac(hmac(hmac(hmac(`AWS4${secret}`, dateStamp), region), service), "aws4_request");
+}
+function signHeaders(input) {
+  const service = input.service ?? "s3";
+  const { amzDate, dateStamp } = timestamps(input.now ?? /* @__PURE__ */ new Date());
+  const headers = {
+    host: input.url.host,
+    "x-amz-content-sha256": input.payloadHash,
+    "x-amz-date": amzDate,
+    ...input.creds.sessionToken ? { "x-amz-security-token": input.creds.sessionToken } : {},
+    ...Object.fromEntries(
+      Object.entries(input.headers ?? {}).map(([k, v]) => [k.toLowerCase(), v])
+    )
+  };
+  const names = Object.keys(headers).sort();
+  const canonicalHeaders = names.map((n) => `${n}:${headers[n].trim()}
+`).join("");
+  const signedHeaders = names.join(";");
+  const canonicalRequest = [
+    input.method.toUpperCase(),
+    canonicalUri(input.url),
+    canonicalQuery([...input.url.searchParams.entries()]),
+    canonicalHeaders,
+    signedHeaders,
+    input.payloadHash
+  ].join("\n");
+  const scope = `${dateStamp}/${input.region}/${service}/aws4_request`;
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    amzDate,
+    scope,
+    sha256Hex(canonicalRequest)
+  ].join("\n");
+  const signature = createHmac(
+    "sha256",
+    signingKey(input.creds.secretAccessKey, dateStamp, input.region, service)
+  ).update(stringToSign, "utf8").digest("hex");
+  headers.authorization = `AWS4-HMAC-SHA256 Credential=${input.creds.accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  return headers;
+}
+function presignUrl(input) {
+  const service = input.service ?? "s3";
+  const method = input.method ?? "GET";
+  const { amzDate, dateStamp } = timestamps(input.now ?? /* @__PURE__ */ new Date());
+  const scope = `${dateStamp}/${input.region}/${service}/aws4_request`;
+  const params = [
+    ...input.url.searchParams.entries(),
+    ["X-Amz-Algorithm", "AWS4-HMAC-SHA256"],
+    ["X-Amz-Credential", `${input.creds.accessKeyId}/${scope}`],
+    ["X-Amz-Date", amzDate],
+    ["X-Amz-Expires", String(Math.floor(input.expiresSec))],
+    ["X-Amz-SignedHeaders", "host"]
+  ];
+  if (input.creds.sessionToken) {
+    params.push(["X-Amz-Security-Token", input.creds.sessionToken]);
+  }
+  const query = canonicalQuery(params);
+  const canonicalRequest = [
+    method.toUpperCase(),
+    canonicalUri(input.url),
+    query,
+    `host:${input.url.host}
+`,
+    "host",
+    "UNSIGNED-PAYLOAD"
+  ].join("\n");
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    amzDate,
+    scope,
+    sha256Hex(canonicalRequest)
+  ].join("\n");
+  const signature = createHmac(
+    "sha256",
+    signingKey(input.creds.secretAccessKey, dateStamp, input.region, service)
+  ).update(stringToSign, "utf8").digest("hex");
+  return `${input.url.origin}${canonicalUri(input.url)}?${query}&X-Amz-Signature=${signature}`;
+}
+
+// src/dump/sinks/credentials.ts
+var REFRESH_MARGIN_MS = 5 * 6e4;
+var METADATA_TIMEOUT_MS = 1e3;
+var cache = null;
+function invalidateCredentials() {
+  cache = null;
+}
+function fromStatic(cfg) {
+  const key = cfg.accessKeyId ?? process.env.FLIGHTBOX_S3_KEY;
+  const secret = cfg.secretAccessKey ?? process.env.FLIGHTBOX_S3_SECRET;
+  if (!key || !secret) return null;
+  return {
+    accessKeyId: key,
+    secretAccessKey: secret,
+    sessionToken: cfg.sessionToken ?? process.env.FLIGHTBOX_S3_TOKEN,
+    source: "static"
+  };
+}
+function fromAwsEnv() {
+  const key = process.env.AWS_ACCESS_KEY_ID;
+  const secret = process.env.AWS_SECRET_ACCESS_KEY;
+  if (!key || !secret) return null;
+  return {
+    accessKeyId: key,
+    secretAccessKey: secret,
+    sessionToken: process.env.AWS_SESSION_TOKEN,
+    source: "aws-env"
+  };
+}
+async function fetchJson(url, init) {
+  try {
+    const res = await fetch(url, {
+      ...init,
+      signal: AbortSignal.timeout(METADATA_TIMEOUT_MS)
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function fromEcs() {
+  const fullUri = process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI;
+  const relativeUri = process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI;
+  if (!fullUri && !relativeUri) return null;
+  const url = fullUri ?? `http://169.254.170.2${relativeUri}`;
+  const body = await fetchJson(url);
+  if (!body?.AccessKeyId || !body?.SecretAccessKey) return null;
+  return {
+    accessKeyId: body.AccessKeyId,
+    secretAccessKey: body.SecretAccessKey,
+    sessionToken: body.Token,
+    expiresAtMs: body.Expiration ? Date.parse(body.Expiration) : void 0,
+    source: "ecs-task-role"
+  };
+}
+async function fromImdsV2() {
+  const base = process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT?.replace(/\/$/, "") ?? "http://169.254.169.254";
+  let token;
+  try {
+    const res = await fetch(`${base}/latest/api/token`, {
+      method: "PUT",
+      headers: { "x-aws-ec2-metadata-token-ttl-seconds": "21600" },
+      signal: AbortSignal.timeout(METADATA_TIMEOUT_MS)
+    });
+    if (!res.ok) return null;
+    token = await res.text();
+  } catch {
+    return null;
+  }
+  const tokenHeader = { "x-aws-ec2-metadata-token": token };
+  let role;
+  try {
+    const res = await fetch(`${base}/latest/meta-data/iam/security-credentials/`, {
+      headers: tokenHeader,
+      signal: AbortSignal.timeout(METADATA_TIMEOUT_MS)
+    });
+    if (!res.ok) return null;
+    role = (await res.text()).split("\n")[0].trim();
+    if (!role) return null;
+  } catch {
+    return null;
+  }
+  const body = await fetchJson(
+    `${base}/latest/meta-data/iam/security-credentials/${role}`,
+    { headers: tokenHeader }
+  );
+  if (!body?.AccessKeyId || !body?.SecretAccessKey) return null;
+  return {
+    accessKeyId: body.AccessKeyId,
+    secretAccessKey: body.SecretAccessKey,
+    sessionToken: body.Token,
+    expiresAtMs: body.Expiration ? Date.parse(body.Expiration) : void 0,
+    source: "ec2-imdsv2"
+  };
+}
+async function resolveCredentials(cfg = {}) {
+  const staticCreds = fromStatic(cfg);
+  if (staticCreds) return staticCreds;
+  const envCreds = fromAwsEnv();
+  if (envCreds) return envCreds;
+  if (cache && (cache.expiresAtMs === void 0 || cache.expiresAtMs - Date.now() > REFRESH_MARGIN_MS)) {
+    return cache;
+  }
+  cache = await fromEcs() ?? await fromImdsV2();
+  return cache;
+}
+
+// src/dump/sinks/s3.ts
+var PUT_TIMEOUT_MS = 3e4;
+var MAX_PRESIGN_SEC = 7 * 24 * 3600;
+function createS3Sink(cfg, defaultViewerOrigin) {
+  const region = cfg.region || (cfg.endpoint ? "auto" : "us-east-1");
+  function objectUrl(key) {
+    if (cfg.endpoint) {
+      return new URL(`${cfg.endpoint.replace(/\/$/, "")}/${cfg.bucket}/${key}`);
+    }
+    return new URL(`https://${cfg.bucket}.s3.${region}.amazonaws.com/${key}`);
+  }
+  return {
+    name: "s3",
+    async deliver(filePath, meta) {
+      const body = await fs4.promises.readFile(filePath);
+      const key = `${cfg.prefix ?? ""}${path5.basename(filePath)}`;
+      let creds = await resolveCredentials(cfg);
+      if (!creds) {
+        return {
+          ok: false,
+          detail: "no AWS credentials resolved (chain: static -> AWS_* env -> ECS task role -> IMDSv2)"
+        };
+      }
+      const put = async (c) => {
+        const url = objectUrl(key);
+        const headers = signHeaders({
+          method: "PUT",
+          url,
+          payloadHash: sha256Hex(body),
+          creds: c,
+          region,
+          headers: {
+            "content-type": "application/gzip",
+            "x-amz-meta-flightbox-trigger": meta.trigger.type
+          }
+        });
+        return fetch(url, {
+          method: "PUT",
+          headers,
+          body,
+          // A hung connection must not leave the delivery promise pending
+          // forever; the file stays staged and the retry pass gets it.
+          signal: AbortSignal.timeout(PUT_TIMEOUT_MS)
+        });
+      };
+      let res = await put(creds);
+      if (res.status === 403) {
+        invalidateCredentials();
+        const fresh = await resolveCredentials(cfg);
+        if (fresh) {
+          creds = fresh;
+          res = await put(fresh);
+        }
+      }
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        return { ok: false, detail: `S3 PUT ${res.status}: ${text.slice(0, 200)}` };
+      }
+      const location = `s3://${cfg.bucket}/${key}`;
+      let viewerUrl;
+      if (cfg.presign?.enabled !== false) {
+        const expiresSec = Math.min(
+          (cfg.presign?.expiresHours ?? 24) * 3600,
+          MAX_PRESIGN_SEC
+        );
+        const presigned = presignUrl({ url: objectUrl(key), creds, region, expiresSec });
+        const origin = (cfg.presign?.viewerOrigin ?? defaultViewerOrigin).replace(/\/$/, "");
+        viewerUrl = `${origin}/?src=${encodeURIComponent(presigned)}`;
+      }
+      return { ok: true, location, viewerUrl };
+    }
+  };
+}
+
+// src/dump/sinks/http.ts
+import * as fs5 from "fs";
+var MAX_ATTEMPTS = 3;
+var POST_TIMEOUT_MS = 3e4;
+function createHttpSink(cfg) {
+  return {
+    name: "http",
+    async deliver(filePath, meta) {
+      const body = await fs5.promises.readFile(filePath);
+      const metaHeader = JSON.stringify(meta).replace(/[\r\n]/g, " ");
+      let lastDetail = "";
+      for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        if (attempt > 0) {
+          await new Promise((r) => setTimeout(r, 500 * 2 ** (attempt - 1)));
+        }
+        try {
+          const res = await fetch(cfg.url, {
+            method: "POST",
+            headers: {
+              "content-type": "application/gzip",
+              "x-flightbox-meta": metaHeader,
+              ...cfg.headers
+            },
+            body,
+            // A stuck connection must never hang delivery forever.
+            signal: AbortSignal.timeout(POST_TIMEOUT_MS)
+          });
+          if (res.ok) return { ok: true, location: cfg.url };
+          lastDetail = `HTTP ${res.status}`;
+          if (res.status >= 400 && res.status < 500 && res.status !== 408 && res.status !== 429) {
+            break;
+          }
+        } catch (err) {
+          lastDetail = err.message;
+        }
+      }
+      return { ok: false, detail: `${lastDetail} after retries \u2014 file kept in staging` };
+    }
+  };
+}
+
+// src/dump/sinks/index.ts
+function createSink(cfg, defaultViewerOrigin) {
+  switch (cfg.type) {
+    case "disk":
+      return createDiskSink(cfg);
+    case "s3":
+      return createS3Sink(cfg, defaultViewerOrigin);
+    case "http":
+      return createHttpSink(cfg);
+  }
+}
+
+// src/triggers/engine.ts
+var CRASH_DEDUPE_MS = 2e3;
+var TriggerEngine = class {
+  constructor(cooldownMs, onFire, onSuppressed) {
+    this.cooldownMs = cooldownMs;
+    this.onFire = onFire;
+    this.onSuppressed = onSuppressed;
+  }
+  cooldownMs;
+  onFire;
+  onSuppressed;
+  lastFireMono = null;
+  lastExemptFireMono = null;
+  fire(info) {
+    const now = nowMono();
+    const windowMs = info.exemptFromCooldown ? CRASH_DEDUPE_MS : this.cooldownMs;
+    const last = info.exemptFromCooldown ? this.lastExemptFireMono : this.lastFireMono;
+    if (last !== null && Number(now - last) / 1e6 < windowMs) {
+      try {
+        this.onSuppressed(info);
+      } catch {
+      }
+      return null;
+    }
+    this.lastFireMono = now;
+    if (info.exemptFromCooldown) this.lastExemptFireMono = now;
+    return this.onFire(info);
+  }
+};
+
+// src/triggers/manual.ts
+function createManualTrigger(engine) {
+  return (reason = "manual trigger") => (
+    // Sync mode: dev-invoked, must return a path to a file that exists.
+    engine.fire({ type: "manual", reason, mode: "sync" })
+  );
+}
+
+// src/triggers/uncaught.ts
+import * as v8 from "v8";
+
+// src/redaction.ts
+var SENSITIVE_MARKERS = [
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "authorization",
+  "auth",
+  "apikey",
+  "api_key",
+  "api-key",
+  "session",
+  "cookie",
+  "otp",
+  "pin",
+  "credential",
+  "private_key",
+  "bearer"
+];
+var JWT_RE = /\beyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{2,}\b/g;
+var KV_RE = /\b(password|passwd|secret|token|authorization|auth|api[_-]?key|apikey|session|cookie|otp|pin|credential|bearer)\b(["']?\s*[=:]\s*)("[^"]*"|'[^']*'|[^\s&,;)}\]]+)/gi;
+var PAN_CANDIDATE_RE = /\b(?:\d[ -]?){13,19}\b/g;
+function needsScrub(s) {
+  const lower = s.toLowerCase();
+  for (const m of SENSITIVE_MARKERS) {
+    if (lower.includes(m)) return true;
+  }
+  if (lower.includes("eyj")) return true;
+  return hasLongDigitRun(s);
+}
+function hasLongDigitRun(s) {
+  let run = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c >= 48 && c <= 57) {
+      if (++run >= 13) return true;
+    } else if (c !== 32 && c !== 45) {
+      run = 0;
+    }
+  }
+  return false;
+}
+function luhnValid(digits) {
+  let sum = 0;
+  let alt = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = digits.charCodeAt(i) - 48;
+    if (d < 0 || d > 9) return false;
+    if (alt) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    alt = !alt;
+  }
+  return sum % 10 === 0;
+}
+function scrubText(s) {
+  if (!needsScrub(s)) return s;
+  let out = s;
+  if (out.toLowerCase().includes("eyj")) {
+    out = out.replace(JWT_RE, "[REDACTED:jwt]");
+  }
+  out = out.replace(KV_RE, "$1$2[REDACTED]");
+  if (hasLongDigitRun(out)) {
+    out = out.replace(PAN_CANDIDATE_RE, (m) => {
+      const digits = m.replace(/[ -]/g, "");
+      return digits.length >= 13 && digits.length <= 19 && luhnValid(digits) ? "[REDACTED:pan]" : m;
+    });
+  }
+  return out;
+}
+function capScrub(s, limit) {
+  const preCapped = s.length > limit * 4 ? s.slice(0, limit * 4) : s;
+  const scrubbed = scrubText(preCapped);
+  return scrubbed.length > limit ? scrubbed.slice(0, limit) : scrubbed;
+}
+var HEADER_ALLOWLIST = /* @__PURE__ */ new Set([
+  "content-type",
+  "content-length",
+  "user-agent",
+  "accept",
+  "x-request-id"
+]);
+function allowlistHeaders(headers) {
+  if (!headers) return void 0;
+  let out;
+  for (const key of Object.keys(headers)) {
+    if (HEADER_ALLOWLIST.has(key.toLowerCase())) {
+      (out ??= {})[key.toLowerCase()] = String(headers[key]);
+    }
+  }
+  return out;
+}
+
+// src/triggers/uncaught.ts
+var OOM_HEAP_FRACTION = 0.94;
+function nearHeapLimit() {
+  try {
+    const stats = v8.getHeapStatistics();
+    return stats.used_heap_size / stats.heap_size_limit > OOM_HEAP_FRACTION;
+  } catch {
+    return false;
+  }
+}
+function crashDump(deps, type, err) {
+  const message = capScrub(String(err?.message ?? err), 512);
+  try {
+    deps.agent.recorder.record(11 /* Custom */, {
+      name: type,
+      message,
+      stack: capScrub(String(err?.stack ?? ""), 2048)
+    });
+  } catch {
+  }
+  if (nearHeapLimit()) {
+    const ok = deps.panicDump();
+    deps.agent.config.log(
+      ok ? `OOM panic path: raw ring dumped; will be converted to .fbox on next boot` : `OOM panic path unavailable (no preopened fd)`
+    );
+    return;
+  }
+  deps.syncDump({ type, reason: message });
+}
+function installCrashTriggers(deps) {
+  const onUncaught = (err) => {
+    try {
+      crashDump(deps, "uncaughtException", err);
+    } catch {
+    }
+  };
+  const onRejection = (reason) => {
+    try {
+      crashDump(deps, "unhandledRejection", reason);
+    } catch {
+    }
+    if (process.listenerCount("unhandledRejection") === 1) {
+      throw reason;
+    }
+  };
+  process.on("uncaughtExceptionMonitor", onUncaught);
+  process.on("unhandledRejection", onRejection);
+  return () => {
+    process.removeListener("uncaughtExceptionMonitor", onUncaught);
+    process.removeListener("unhandledRejection", onRejection);
+  };
+}
+
+// src/triggers/slow-request.ts
+var inFlight = /* @__PURE__ */ new Map();
+function trackRequestStart(requestId, method, path8) {
+  inFlight.set(requestId, { method, path: path8, startedAtMs: Date.now(), fired: false });
+}
+function trackRequestEnd(requestId) {
+  inFlight.delete(requestId);
+}
+function maybeFireSlow(agent, method, path8, durMs) {
+  if (durMs > agent.config.triggers.slowRequestMs) {
+    agent.fire({
+      type: "slowRequest",
+      reason: `${method} ${path8} took ${durMs.toFixed(0)}ms (threshold ${agent.config.triggers.slowRequestMs}ms)`
+    });
+  }
+}
+function startWatchdog(agent) {
+  const interval = setInterval(() => {
+    try {
+      const now = Date.now();
+      const threshold = agent.config.triggers.slowRequestMs;
+      for (const entry of inFlight.values()) {
+        if (!entry.fired && now - entry.startedAtMs > threshold) {
+          entry.fired = true;
+          agent.fire({
+            type: "slowRequest",
+            reason: `${entry.method} ${entry.path} still in flight after ${(now - entry.startedAtMs).toFixed(0)}ms (watchdog)`
+          });
+        }
+      }
+    } catch {
+    }
+  }, 1e3);
+  interval.unref();
+  return () => {
+    clearInterval(interval);
+    inFlight.clear();
+  };
+}
+
+// src/instrumentations/http-server.ts
+import * as http from "http";
+import { createHash as createHash2, timingSafeEqual } from "crypto";
+var patched = false;
+var agentRef;
+function tokenMatches(supplied, expected) {
+  const a = createHash2("sha256").update(supplied).digest();
+  const b = createHash2("sha256").update(expected).digest();
+  return timingSafeEqual(a, b);
+}
+function handleFlightboxEndpoint(agent, req, res) {
+  if (!agent.config.token || !req.url?.startsWith("/__flightbox/dump")) return false;
+  try {
+    const url = new URL(req.url, "http://localhost");
+    if (url.pathname !== "/__flightbox/dump") return false;
+    if (req.method !== "GET") {
+      res.writeHead(405, { allow: "GET" }).end();
+      return true;
+    }
+    const supplied = String(req.headers["x-flightbox-token"] ?? "");
+    if (!supplied || !tokenMatches(supplied, agent.config.token)) {
+      res.writeHead(401, { "content-type": "application/json" });
+      res.end('{"error":"invalid token"}');
+      return true;
+    }
+    const rawReason = url.searchParams.get("reason") ?? "no reason given";
+    const reason = truncate(scrubText(truncate(rawReason, 512)), 120);
+    const staged = agent.fire({
+      type: "manual",
+      reason: `http endpoint (${reason})`,
+      mode: "sync"
+      // interactive call: the returned path must exist
+    });
+    res.writeHead(staged ? 200 : 429, { "content-type": "application/json" });
+    res.end(JSON.stringify({ staged: staged ?? null, suppressed: staged === null }));
+  } catch {
+    try {
+      res.writeHead(500);
+      res.end();
+    } catch {
+    }
+  }
+  return true;
+}
+function instrumentHttpServer(agent) {
+  agentRef = agent;
+  if (patched) return;
+  patched = true;
+  const orig = http.Server.prototype.emit;
+  const flightboxEmit = function(event) {
+    const args = arguments;
+    if (event !== "request") {
+      return orig.apply(this, args);
+    }
+    const agent2 = agentRef;
+    try {
+      if (handleFlightboxEndpoint(agent2, args[1], args[2])) {
+        return true;
+      }
+    } catch {
+    }
+    if (isShedding()) {
+      return orig.apply(this, args);
+    }
+    let ctx;
+    try {
+      const req = args[1];
+      const res = args[2];
+      const requestId = newRequestId();
+      const tStart = nowMono();
+      const method = req.method ?? "GET";
+      const path8 = capScrub(req.url ?? "", LIMITS.path);
+      ctx = { requestId };
+      agent2.recorder.record(
+        1 /* HttpServerStart */,
+        // Bible §7: headers are allowlisted (content-type, user-agent, ...)
+        // — never captured wholesale.
+        { method, path: path8, headers: allowlistHeaders(req.headers) },
+        { requestId, tMonoNs: tStart }
+      );
+      trackRequestStart(requestId, method, path8);
+      const finish = (aborted) => {
+        try {
+          trackRequestEnd(requestId);
+          const durMs = Number(nowMono() - tStart) / 1e6;
+          agent2.recorder.record(
+            2 /* HttpServerEnd */,
+            aborted ? { method, path: path8, aborted: true, durMs } : { method, path: path8, status: res.statusCode, durMs },
+            { requestId }
+          );
+          maybeFireSlow(agent2, method, path8, durMs);
+        } catch {
+        }
+        ctx.requestId = 0n;
+      };
+      res.once("finish", () => finish(false));
+      res.once("close", () => {
+        if (!res.writableFinished) finish(true);
+      });
+    } catch {
+      return orig.apply(this, args);
+    }
+    return requestStorage.run(ctx, () => orig.apply(this, args));
+  };
+  http.Server.prototype.emit = flightboxEmit;
+}
+
+// src/instrumentations/http-client.ts
+import { createRequire } from "module";
+var patched2 = false;
+var agentRef2;
+function extractTarget(args) {
+  let method = "GET";
+  let host = "";
+  let path8 = "";
+  const a0 = args[0];
+  if (typeof a0 === "string") {
+    try {
+      const u = new URL(a0);
+      host = u.host;
+      path8 = u.pathname + u.search;
+    } catch {
+      path8 = a0;
+    }
+  } else if (a0 instanceof URL) {
+    host = a0.host;
+    path8 = a0.pathname + a0.search;
+  } else if (a0 && typeof a0 === "object") {
+    const o = a0;
+    host = o.host ?? o.hostname ?? "";
+    path8 = o.path ?? "/";
+    method = o.method ?? "GET";
+  }
+  const a1 = args[1];
+  if (a1 && typeof a1 === "object" && !(a1 instanceof URL) && typeof a1 !== "function") {
+    const o = a1;
+    if (o.method) method = o.method;
+    if (o.host || o.hostname) host = o.host ?? o.hostname;
+  }
+  return { method: String(method).toUpperCase(), host: String(host), path: String(path8) };
+}
+var nodeRequire = createRequire(process.cwd() + "/noop.js");
+function wrapModule(mod) {
+  const origRequest = mod.request.bind(mod);
+  const tracedRequest = function(...args) {
+    if (isShedding()) return origRequest(...args);
+    const agent = agentRef2;
+    let spanId = 0n;
+    let requestId = 0n;
+    let tStart = 0n;
+    let recordedStart = false;
+    try {
+      const target = extractTarget(args);
+      spanId = newSpanId();
+      requestId = currentRequestId();
+      tStart = nowMono();
+      agent.recorder.record(
+        3 /* HttpClientStart */,
+        {
+          method: target.method,
+          host: truncate(target.host, 256),
+          path: capScrub(target.path, LIMITS.path)
+        },
+        { spanId, requestId, tMonoNs: tStart }
+      );
+      recordedStart = true;
+    } catch {
+    }
+    const req = origRequest(...args);
+    if (recordedStart) {
+      const done = (status, error) => {
+        try {
+          const payload = {
+            durMs: Number(nowMono() - tStart) / 1e6
+          };
+          if (status !== void 0) payload.status = status;
+          if (error !== void 0) payload.error = capScrub(error, 256);
+          agent.recorder.record(4 /* HttpClientEnd */, payload, { spanId, requestId });
+        } catch {
+        }
+      };
+      try {
+        req.once("response", (res) => done(res.statusCode));
+        req.once("error", (err) => {
+          done(void 0, err.message);
+          if (req.listenerCount("error") === 0) throw err;
+        });
+      } catch {
+      }
+    }
+    return req;
+  };
+  mod.request = tracedRequest;
+  mod.get = function(...args) {
+    const req = tracedRequest(...args);
+    req.end();
+    return req;
+  };
+}
+function wrapFetch() {
+  const origFetch = globalThis.fetch;
+  if (typeof origFetch !== "function") return;
+  globalThis.fetch = async function flightboxFetch(input, init) {
+    if (isShedding()) return origFetch(input, init);
+    const agent = agentRef2;
+    let spanId = 0n;
+    let requestId = 0n;
+    let tStart = 0n;
+    let recordedStart = false;
+    try {
+      const url = typeof input === "string" ? input : input?.url ?? String(input);
+      let host = "";
+      let path8 = String(url);
+      try {
+        const u = new URL(url);
+        host = u.host;
+        path8 = u.pathname + u.search;
+      } catch {
+      }
+      spanId = newSpanId();
+      requestId = currentRequestId();
+      tStart = nowMono();
+      agent.recorder.record(
+        3 /* HttpClientStart */,
+        {
+          method: String(
+            init?.method ?? (typeof input === "object" ? input?.method : void 0) ?? "GET"
+          ).toUpperCase(),
+          host: truncate(host, 256),
+          path: capScrub(path8, LIMITS.path),
+          via: "fetch"
+        },
+        { spanId, requestId, tMonoNs: tStart }
+      );
+      recordedStart = true;
+    } catch {
+    }
+    const done = (status, error) => {
+      if (!recordedStart) return;
+      try {
+        const payload = { durMs: Number(nowMono() - tStart) / 1e6 };
+        if (status !== void 0) payload.status = status;
+        if (error !== void 0) payload.error = capScrub(error, 256);
+        agent.recorder.record(4 /* HttpClientEnd */, payload, { spanId, requestId });
+      } catch {
+      }
+    };
+    try {
+      const res = await origFetch(input, init);
+      done(res.status);
+      return res;
+    } catch (err) {
+      done(void 0, err?.message ?? String(err));
+      throw err;
+    }
+  };
+}
+function instrumentHttpClient(agent) {
+  agentRef2 = agent;
+  if (patched2) return;
+  patched2 = true;
+  try {
+    wrapModule(nodeRequire("node:http"));
+  } catch {
+  }
+  try {
+    wrapModule(nodeRequire("node:https"));
+  } catch {
+  }
+  try {
+    wrapFetch();
+  } catch {
+  }
+}
+
+// src/instrumentations/pg.ts
+import { createRequire as createRequire2 } from "module";
+import * as path6 from "path";
+function loadPg() {
+  try {
+    const req = createRequire2(path6.join(process.cwd(), "noop.js"));
+    return req("pg");
+  } catch {
+    return null;
+  }
+}
+function paramShapes(values) {
+  if (!Array.isArray(values)) return void 0;
+  return values.slice(0, 32).map((v) => v === null ? "null" : Array.isArray(v) ? "array" : typeof v);
+}
+var agentRef3;
+function instrumentPg(agent) {
+  agentRef3 = agent;
+  const recorder = {
+    record: ((...args) => agentRef3.recorder.record(...args))
+  };
+  const pg = loadPg();
+  if (!pg?.Client?.prototype?.query) return false;
+  if (!pg.Client.prototype.query.__flightbox) {
+    const origQuery = pg.Client.prototype.query;
+    const wrappedQuery = function(...args) {
+      if (isShedding()) return origQuery.apply(this, args);
+      let spanId = 0n;
+      let requestId = 0n;
+      let tStart = 0n;
+      let recordedStart = false;
+      try {
+        const first = args[0];
+        const text = typeof first === "string" ? first : first?.text;
+        const values = Array.isArray(args[1]) ? args[1] : Array.isArray(first?.values) ? first.values : void 0;
+        spanId = newSpanId();
+        requestId = currentRequestId();
+        tStart = nowMono();
+        recorder.record(
+          5 /* PgQueryStart */,
+          {
+            text: capScrub(typeof text === "string" ? text : "<unknown>", LIMITS.query),
+            params: paramShapes(values)
+          },
+          { spanId, requestId, tMonoNs: tStart }
+        );
+        recordedStart = true;
+      } catch {
+      }
+      const done = (err) => {
+        if (!recordedStart) return;
+        try {
+          const payload = {
+            durMs: Number(nowMono() - tStart) / 1e6
+          };
+          if (err) {
+            payload.error = truncate(String(err?.message ?? err), 256);
+          }
+          recorder.record(6 /* PgQueryEnd */, payload, { spanId, requestId });
+        } catch {
+        }
+      };
+      try {
+        const last = args[args.length - 1];
+        if (typeof last === "function") {
+          args[args.length - 1] = function(err) {
+            done(err);
+            return last.apply(this, arguments);
+          };
+          return origQuery.apply(this, args);
+        }
+      } catch {
+      }
+      const out = origQuery.apply(this, args);
+      try {
+        if (out && typeof out.then === "function") {
+          return out.then(
+            (v) => {
+              done();
+              return v;
+            },
+            (e) => {
+              done(e);
+              throw e;
+            }
+          );
+        }
+        if (out && typeof out.on === "function") {
+          out.once("end", () => done());
+          out.once("error", (e) => {
+            done(e);
+            if (out.listenerCount("error") === 0) throw e;
+          });
+        }
+      } catch {
+      }
+      return out;
+    };
+    wrappedQuery.__flightbox = true;
+    pg.Client.prototype.query = wrappedQuery;
+  }
+  const Pool = pg.Pool;
+  if (Pool?.prototype?.connect && !Pool.prototype.connect.__flightbox) {
+    const origConnect = Pool.prototype.connect;
+    const wrappedConnect = function(cb) {
+      if (isShedding()) return origConnect.call(this, cb);
+      const tStart = nowMono();
+      const requestId = currentRequestId();
+      const record = () => {
+        try {
+          recorder.record(
+            7 /* PgPoolWait */,
+            { waitMs: Number(nowMono() - tStart) / 1e6 },
+            { requestId }
+          );
+        } catch {
+        }
+      };
+      if (typeof cb === "function") {
+        return origConnect.call(this, function(...cbArgs) {
+          record();
+          return cb.apply(this, cbArgs);
+        });
+      }
+      const out = origConnect.call(this);
+      try {
+        if (out && typeof out.then === "function") out.then(record, record);
+      } catch {
+      }
+      return out;
+    };
+    wrappedConnect.__flightbox = true;
+    Pool.prototype.connect = wrappedConnect;
+  }
+  return true;
+}
+
+// src/instrumentations/console.ts
+import { formatWithOptions } from "util";
+var LEVELS = ["log", "info", "warn", "error", "debug"];
+var FORMAT_OPTS = { depth: 2, maxArrayLength: 20, maxStringLength: LIMITS.log };
+var patched3 = false;
+var agentRef4;
+function instrumentConsole(agent) {
+  agentRef4 = agent;
+  if (patched3) return;
+  patched3 = true;
+  for (const level of LEVELS) {
+    const orig = console[level].bind(console);
+    console[level] = function flightboxConsole(...args) {
+      try {
+        if (!isShedding()) {
+          const msg = capScrub(formatWithOptions(FORMAT_OPTS, ...args), LIMITS.log);
+          agentRef4.recorder.record(8 /* Log */, { level, msg });
+        }
+      } catch {
+      }
+      orig(...args);
+    };
+  }
+}
+
+// src/instrumentations/registry.ts
+var INSTRUMENTATIONS = [
+  ["http-server", instrumentHttpServer],
+  ["http-client", instrumentHttpClient],
+  ["pg", instrumentPg],
+  ["console", instrumentConsole]
+];
+function applyInstrumentations(agent) {
+  for (const [name, apply] of INSTRUMENTATIONS) {
+    try {
+      if (apply(agent) === false) {
+        agent.config.log(`instrumentation ${name}: module not present, skipped`);
+      }
+    } catch (err) {
+      agent.config.log(`instrumentation ${name} failed to apply: ${err.message}`);
+    }
+  }
+}
+
+// src/instrumentations/vitals.ts
+import { monitorEventLoopDelay } from "perf_hooks";
+import * as v82 from "v8";
+function startVitals(agent) {
+  const histogram = monitorEventLoopDelay({ resolution: 20 });
+  histogram.enable();
+  const { shedLagMs } = agent.config.shedding;
+  const { heapPct, stallMs } = agent.config.triggers;
+  const heapLimit = v82.getHeapStatistics().heap_size_limit;
+  let memAbove = false;
+  let stallAbove = false;
+  const interval = setInterval(() => {
+    try {
+      const lagMs = histogram.mean / 1e6;
+      const maxLagMs = histogram.max / 1e6;
+      histogram.reset();
+      const mem = process.memoryUsage();
+      agent.recorder.record(9 /* Vitals */, {
+        lagMs: Math.round(lagMs * 1e3) / 1e3,
+        maxLagMs: Math.round(maxLagMs * 1e3) / 1e3,
+        heapUsed: mem.heapUsed,
+        heapTotal: mem.heapTotal,
+        rss: mem.rss
+      });
+      if (!isShedding() && lagMs > shedLagMs) {
+        setShedding(true);
+        agent.recorder.record(11 /* Custom */, {
+          name: "flightbox.shedding",
+          on: true,
+          lagMs: Math.round(lagMs)
+        });
+        agent.config.log(
+          `event-loop lag ${lagMs.toFixed(0)}ms > ${shedLagMs}ms \u2014 load-shedding ON (ADR 012)`
+        );
+      } else if (isShedding() && lagMs < shedLagMs / 2) {
+        setShedding(false);
+        agent.recorder.record(11 /* Custom */, {
+          name: "flightbox.shedding",
+          on: false,
+          lagMs: Math.round(lagMs)
+        });
+        agent.config.log("event-loop lag recovered \u2014 load-shedding OFF");
+      }
+      const heapFrac = mem.heapUsed / heapLimit;
+      if (heapFrac > heapPct && !memAbove) {
+        memAbove = true;
+        agent.fire({
+          type: "memory",
+          reason: `heapUsed at ${(heapFrac * 100).toFixed(0)}% of V8 limit`
+        });
+      } else if (memAbove && heapFrac < heapPct * 0.9) {
+        memAbove = false;
+      }
+      if (maxLagMs > stallMs && !stallAbove) {
+        stallAbove = true;
+        agent.fire({
+          type: "eventloop-stall",
+          reason: `event loop stalled ${maxLagMs.toFixed(0)}ms (threshold ${stallMs}ms)`
+        });
+      } else if (stallAbove && maxLagMs < stallMs / 2) {
+        stallAbove = false;
+      }
+    } catch {
+    }
+  }, 100);
+  interval.unref();
+  return () => {
+    clearInterval(interval);
+    histogram.disable();
+  };
+}
+
+// src/index.ts
+var SINK_RETRY_INTERVAL_MS = 5 * 6e4;
+var EMERGENCY_RING_BYTES = 4 * 1024 * 1024;
+var instance = null;
+function start(userConfig = {}) {
+  if (instance) return;
+  const config = resolveConfig(userConfig);
+  if (!isMainThread && !config.allowWorkerThreads) {
+    config.log(
+      "worker thread detected \u2014 agent not started (each thread would allocate its own ring buffer; see ADR 014). Set allowWorkerThreads: true to record in this thread anyway."
+    );
+    return;
+  }
+  anchorClock();
+  const recorder = new Recorder(new RingBuffer(config.bufferMb * 1024 * 1024));
+  const staging = new Staging(config.dir, config.staging, config.log);
+  staging.claimOrphanedSync();
+  recoverPanicFiles(staging, config.service, config.log);
+  const unsent = recoverOnBoot(staging, config.log);
+  const panicWriter = new PanicWriter(staging.stagingDir);
+  panicWriter.arm();
+  const sinks = config.sinks.map((cfg) => createSink(cfg, config.viewerOrigin));
+  const engine = new TriggerEngine(
+    config.triggers.cooldownMs,
+    (info) => dump(info),
+    (info) => recorder.record(10 /* Trigger */, {
+      suppressed: true,
+      triggerType: info.type,
+      reason: info.reason
+    })
+  );
+  const agent = {
+    recorder,
+    config,
+    fire: (info) => engine.fire(info)
+  };
+  instance = {
+    config,
+    recorder,
+    staging,
+    engine,
+    panicWriter,
+    sinks,
+    manualTrigger: createManualTrigger(engine),
+    teardowns: [],
+    deliveryInFlight: /* @__PURE__ */ new Set()
+  };
+  applyInstrumentations(agent);
+  instance.teardowns.push(startWatchdog(agent));
+  instance.teardowns.push(startVitals(agent));
+  instance.teardowns.push(
+    installCrashTriggers({
+      agent,
+      // Crash dumps bypass the routine cooldown (a slow-request dump minutes
+      // ago must never cost us the final-moments dump); the engine's short
+      // crash window still collapses rejection→rethrow→uncaught to one file.
+      syncDump: (info) => engine.fire({ ...info, mode: "sync", exemptFromCooldown: true }),
+      panicDump: () => panicWriter.writeSync(recorder.activeRing)
+    })
+  );
+  recorder.armed = true;
+  config.log(
+    `armed \u2014 ${config.bufferMb}MB ring buffer, staging at ${staging.stagingDir}` + (sinks.length ? `, sinks: ${sinks.map((s) => s.name).join("+")}` : ", no sinks (staging only)")
+  );
+  if (sinks.length > 0 && unsent.length > 0) {
+    void deliverRecovered(instance, unsent);
+  }
+  if (sinks.length > 0) {
+    const inst = instance;
+    const retry = setInterval(() => void retryStaged(inst), SINK_RETRY_INTERVAL_MS);
+    retry.unref();
+    instance.teardowns.push(() => clearInterval(retry));
+  }
+}
+async function retryStaged(inst) {
+  try {
+    for (const file of inst.staging.listStagedSync()) {
+      if (inst.deliveryInFlight.has(file)) continue;
+      const meta = readMetaSync(file);
+      if (!meta) continue;
+      inst.config.log(`retrying delivery of ${path7.basename(file)}...`);
+      await deliverFile(inst, file, meta);
+    }
+  } catch {
+  }
+}
+function readMetaSync(filePath) {
+  try {
+    const parsed = JSON.parse(zlib.gunzipSync(fs6.readFileSync(filePath)).toString("utf8"));
+    return parsed?.meta ?? null;
+  } catch {
+    return null;
+  }
+}
+async function deliverRecovered(inst, files) {
+  for (const file of files) {
+    const meta = readMetaSync(file);
+    if (!meta) continue;
+    inst.config.log(`delivering recovered incident ${path7.basename(file)}...`);
+    await deliverFile(inst, file, meta);
+  }
+}
+async function deliverFile(inst, filePath, meta) {
+  if (inst.sinks.length === 0 || inst.deliveryInFlight.has(filePath)) return;
+  inst.deliveryInFlight.add(filePath);
+  try {
+    await deliverFileInner(inst, filePath, meta);
+  } finally {
+    inst.deliveryInFlight.delete(filePath);
+  }
+}
+async function deliverFileInner(inst, filePath, meta) {
+  let allOk = true;
+  let viewerUrl;
+  for (const sink of inst.sinks) {
+    try {
+      const result = await sink.deliver(filePath, meta);
+      if (result.ok) {
+        if (result.location) inst.config.log(`   stored:  ${result.location}`);
+        viewerUrl ??= result.viewerUrl;
+      } else {
+        allOk = false;
+        inst.config.log(`   sink ${sink.name} failed: ${result.detail ?? "unknown error"}`);
+      }
+    } catch (err) {
+      allOk = false;
+      inst.config.log(`   sink ${sink.name} threw: ${err.message}`);
+    }
+  }
+  if (viewerUrl) inst.config.log(`   open:    ${viewerUrl}`);
+  if (allOk) {
+    try {
+      inst.staging.markDeliveredSync(filePath);
+    } catch {
+    }
+  }
+}
+function dump(info) {
+  const inst = instance;
+  if (!inst) return null;
+  inst.recorder.record(10 /* Trigger */, {
+    triggerType: info.type,
+    reason: info.reason
+  });
+  const replacement = info.type === "memory" ? EMERGENCY_RING_BYTES : void 0;
+  if (replacement) {
+    inst.config.log(
+      `memory trigger: recording continues in a ${EMERGENCY_RING_BYTES / 1048576}MB emergency ring until pressure clears`
+    );
+  }
+  const events = takeFrozenSnapshot(inst.recorder, replacement);
+  const prepared = buildIncident({
+    service: inst.config.service,
+    trigger: { type: info.type, reason: info.reason },
+    events
+  });
+  const finalize = (data) => {
+    let stagedPath;
+    try {
+      stagedPath = inst.staging.stageSync(prepared.fileName, data);
+    } catch (err) {
+      if (err instanceof DiskFullError) {
+        inst.recorder.armed = false;
+        inst.config.log(`DISK CRITICAL \u2014 ${err.message}. Agent disabled.`);
+        return null;
+      }
+      inst.config.log(`failed to stage incident: ${err.message}`);
+      return null;
+    }
+    inst.config.log(
+      `\u{1F534} incident captured (${(data.length / 1024).toFixed(1)} KB gz, ${prepared.eventCount} events, ${(prepared.windowMs / 1e3).toFixed(1)}s window)`
+    );
+    inst.config.log(`   trigger: ${info.type}${info.reason ? ` \u2014 ${info.reason}` : ""}`);
+    inst.config.log(`   staged:  ${stagedPath}`);
+    void deliverFile(inst, stagedPath, prepared.meta);
+    return stagedPath;
+  };
+  if (info.mode === "sync") {
+    return finalize(zlib.gzipSync(prepared.json, { level: DUMP_GZIP_LEVEL }));
+  }
+  const prospectivePath = path7.join(inst.staging.stagingDir, prepared.fileName);
+  zlib.gzip(prepared.json, { level: DUMP_GZIP_LEVEL }, (err, data) => {
+    if (err) {
+      inst.config.log(`gzip failed for ${prepared.fileName}: ${err.message}`);
+      return;
+    }
+    finalize(data);
+  });
+  return prospectivePath;
+}
+function trigger(reason) {
+  return instance ? instance.manualTrigger(reason) : null;
+}
+function addEvent(name, data = {}) {
+  instance?.recorder.record(11 /* Custom */, {
+    name: truncate(name, LIMITS.path),
+    ...data
+  });
+}
+function stop() {
+  if (instance) {
+    instance.recorder.armed = false;
+    for (const teardown of instance.teardowns) {
+      try {
+        teardown();
+      } catch {
+      }
+    }
+    instance.panicWriter.disarm();
+    setShedding(false);
+    instance = null;
+  }
+}
+var index_default = { start, stop, trigger, addEvent };
+
+export {
+  start,
+  trigger,
+  addEvent,
+  stop,
+  index_default
+};
+//# sourceMappingURL=chunk-HCJF2ASP.mjs.map