logroller 2.1.0 → 3.0.0

package/dist/index.esm.js

@@ -1,1331 +1,2 @@
-/*! logroller v2.1.0 | MIT License */
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { Writable } from 'node:stream';
-import zlib from 'node:zlib';
-import { pipeline } from 'node:stream/promises';
-
-/** `stat().size` guarded to 0; string paths only. */
-const statSizeSafe = (p) => {
-    try {
-        return typeof p === "string" ? fs.statSync(p).size : 0;
-    }
-    catch {
-        return 0;
-    }
-};
-const existsSafe = (p) => {
-    try {
-        return fs.existsSync(p);
-    }
-    catch {
-        return false;
-    }
-};
-/**
- * Compress `src` → `dst` at gzip `level`, deleting `src` ONLY on verified
- * success. On failure removes the partial `dst` and reports via callback —
- * logs degrade to uncompressed rather than losing data.
- */
-async function gzipMove(src, dst, onWarn, level = 6) {
-    try {
-        await pipeline(fs.createReadStream(src), zlib.createGzip({ level }), fs.createWriteStream(dst));
-        await fs.promises.unlink(src);
-        return true;
-    }
-    catch (err) {
-        await fs.promises.unlink(dst).catch(() => { });
-        onWarn?.(err);
-        return false;
-    }
-}
-const endStream = (ws) => ws ? new Promise((resolve) => ws.end(() => resolve())) : Promise.resolve();
-
-const UNITS = {
-    b: 1,
-    k: 1024,
-    kb: 1024,
-    m: 1048576,
-    mb: 1048576,
-    g: 1073741824,
-    gb: 1073741824,
-};
-/**
- * Every unit token the duration regex can capture MUST have an entry here —
- * a captured-but-unmapped unit would otherwise surface as a NaN that
- * detonates later (e.g. `RangeError: Invalid time value` from Intl),
- * far away from the actual misconfiguration.
- */
-const DURATION_ALIASES = {
-    ms: 1,
-    s: 1_000,
-    m: 60_000,
-    h: 3_600_000,
-    hour: 3_600_000,
-    hours: 3_600_000,
-};
-/**
- * Parse `"<n><unit?>"` or a bare number into milliseconds.
- * Bare numbers are interpreted in `defaultUnit`.
- *
- * Accepted unit spellings: ms, s, m, h, hour, hours (case-insensitive).
- */
-function parseDuration(value, defaultUnit, fieldName) {
-    if (typeof value === "number") {
-        return Math.round(value * DURATION_ALIASES[defaultUnit]);
-    }
-    const m = /^\s*(-?\d+(?:\.\d+)?)\s*(h(?:our)?s?|ms|s|m)?\s*$/i.exec(value);
-    if (!m)
-        throw new Error(`Invalid ${fieldName} "${value}"`);
-    const unit = (m[2] ?? defaultUnit).toLowerCase();
-    const mult = DURATION_ALIASES[unit];
-    if (mult === undefined) {
-        throw new Error(`Invalid ${fieldName} unit "${m[2]}" in "${value}"`);
-    }
-    return Math.round(Number.parseFloat(m[1]) * mult);
-}
-function parseSize(v) {
-    if (v === undefined || v === null || v === 0)
-        return 0;
-    if (typeof v === "number")
-        return v;
-    const m = /^\s*(\d+(?:\.\d+)?)\s*(b|kb|k|mb|m|gb|g)?\s*$/i.exec(v);
-    if (!m)
-        throw new Error(`Invalid maxSize "${v}"`);
-    return Math.round(Number.parseFloat(m[1]) * (UNITS[m[2]?.toLowerCase()] ?? 1));
-}
-function parseMaxFiles(v) {
-    if (v === undefined || v === null || v === "" || v === 0)
-        return null;
-    if (typeof v === "number") {
-        if (v < 0)
-            throw new Error(`Invalid maxFiles "${v}"`);
-        return { count: v };
-    }
-    const m = /^\s*(\d+)\s*d\s*$/i.exec(v);
-    if (m)
-        return { days: Number.parseInt(m[1], 10) };
-    const n = /^\s*(\d+)\s*$/.exec(v);
-    if (n)
-        return { count: Number.parseInt(n[1], 10) };
-    throw new Error(`Invalid maxFiles "${v}"`);
-}
-function parseFrequency(v) {
-    if (v === undefined || v === null)
-        return { type: "daily" };
-    if (v === "daily")
-        return { type: "daily" };
-    if (typeof v === "number") {
-        if (v <= 0)
-            throw new Error(`Invalid frequency "${v}"`);
-        return { type: "interval", ms: v };
-    }
-    const m = /^\s*(\d+)\s*(ms|s|m|h)\s*$/i.exec(v);
-    if (!m)
-        throw new Error(`Invalid frequency "${v}"`);
-    return { type: "interval", ms: Number.parseInt(m[1], 10) * FREQ_MULT[m[2].toLowerCase()] };
-}
-const FREQ_MULT = {
-    ms: 1,
-    s: 1_000,
-    m: 60_000,
-    h: 3_600_000,
-};
-/** Static virtual-clock shift. Accepts hours by default; h/hours/m/s/ms. */
-function parseClockOffset(v) {
-    if (v === undefined || v === null || v === "")
-        return 0;
-    return parseDuration(v, "h", "addHours");
-}
-/** Per-tick virtual-clock step. Accepts hours by default; h/hours/m/s/ms. */
-function parseClockStep(v) {
-    if (v === undefined || v === null || v === "")
-        return 0;
-    return parseDuration(v, "h", "addHoursEveryMin");
-}
-
-/* Timezone-aware helpers built exclusively on Intl (zero deps). */
-const _dtfCache = new Map();
-/** Cached `Intl.DateTimeFormat`; throws synchronously for invalid zones. */
-function getDtf(tz) {
-    let dtf = _dtfCache.get(tz);
-    if (!dtf) {
-        try {
-            dtf = new Intl.DateTimeFormat("en-US", {
-                timeZone: tz,
-                hourCycle: "h23",
-                year: "numeric",
-                month: "2-digit",
-                day: "2-digit",
-                hour: "2-digit",
-                minute: "2-digit",
-                second: "2-digit",
-            });
-        }
-        catch {
-            throw new Error(`Invalid timeZone "${tz}"`);
-        }
-        _dtfCache.set(tz, dtf);
-    }
-    return dtf;
-}
-function partsIn(tz, date) {
-    const o = {};
-    for (const p of getDtf(tz).formatToParts(date))
-        o[p.type] = p.value;
-    return o;
-}
-const pad2 = (n) => n.padStart(2, "0");
-/** Escape a literal string for embedding inside a RegExp. */
-function escRe(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
-}
-/** Substitute YYYY|YY|MM|DD|HH|mm|ss tokens in `pattern`. */
-function formatStamp(pattern, parts) {
-    return pattern.replace(/YYYY|YY|MM|DD|HH|mm|ss/g, (token) => {
-        switch (token) {
-            case "YYYY":
-                return parts.year;
-            case "YY":
-                return parts.year.slice(-2);
-            case "MM":
-                return pad2(parts.month);
-            case "DD":
-                return pad2(parts.day);
-            case "HH":
-                return pad2(parts.hour);
-            case "mm":
-                return pad2(parts.minute);
-            case "ss":
-                return pad2(parts.second);
-            default:
-                return token;
-        }
-    });
-}
-/** Offset of `tz` vs UTC at instant `date`, milliseconds. */
-function tzOffsetMs(tz, date) {
-    const p = partsIn(tz, date);
-    return (Date.UTC(+p.year, +p.month - 1, +p.day, +p.hour, +p.minute, +p.second) -
-        (date.getTime() - (date.getTime() % 1000)));
-}
-/** Next local midnight in `tz`, DST-corrected by fixed-point iteration. */
-function nextMidnight(tz, fromMs) {
-    const p = partsIn(tz, new Date(fromMs));
-    const localNext = Date.UTC(+p.year, +p.month - 1, +p.day + 1);
-    let inst = localNext - tzOffsetMs(tz, new Date(localNext));
-    for (let i = 0; i < 3; i++) {
-        const cand = localNext - tzOffsetMs(tz, new Date(inst));
-        if (cand === inst)
-            break;
-        inst = cand;
-    }
-    if (inst <= fromMs)
-        inst += 86_400_000;
-    return inst;
-}
-/** Next epoch-aligned boundary (e.g. hh:00 for step = 1h). */
-const nextAligned = (from, step) => Math.floor(from / step) * step + step;
-
-const BUMP_DEFAULT_MS = 60_000;
-const AUDIT_MAX_FILES = 600;
-const AUDIT_MAX_EVENTS = 200;
-const HEARTBEAT_STALE_MS = 30_000;
-const TIMER_POLL_MS = 1_000;
-const emptyAudit = (prefix, ext, datePattern, tz) => ({
-    version: 1,
-    prefix,
-    ext,
-    datePattern,
-    tz,
-    createdAt: null,
-    updatedAt: null,
-    activeStamp: null,
-    activeIndex: null,
-    writer: null,
-    files: {},
-    events: [],
-});
-/**
- * A `Writable` that appends to dated log files, rolling segments on time
- * and/or size, optionally gzipping sealed segments, enforcing retention
- * (count, age, and total-byte budget), maintaining a stable "current"
- * symlink for log collectors, running an awaited seal hook (upload
- * pipeline), and resuming an unbroken series across restarts via disk
- * scan + audit manifest.
- *
- * @example
- * ```ts
- * const log = createStream({
- *   filename: "logs/app-%DATE%.log",
- *   maxSize: "20m",
- *   maxTotalSize: "5g",
- *   maxFiles: "90d",
- *   zippedArchive: true,
- *   symlink: true,
- *   onSeal: async ({ gz }) => uploadToS3(gz),
- * });
- * log.write("hello\n");          // or: readable.pipe(log)
- * ```
- */
-class RotateFileStream extends Writable {
-    tz;
-    template;
-    dir;
-    datePattern;
-    zippedArchive;
-    maxSize;
-    maxFiles;
-    freq;
-    unrefTimers;
-    maxTotalSize;
-    /* ---- filename-template pieces ---- */
-    _tL;
-    _tMid;
-    _tExt;
-    _rxFor;
-    _rxActive;
-    /* ---- audit manifest ---- */
-    _auditEnabled;
-    _auditPath;
-    _bootId = randomUUID();
-    _onSeal;
-    _sealHookTimeoutMs;
-    _compressionLevel;
-    _symlinkPath = null;
-    /* ---- virtual test clock ---- */
-    _offsetMs;
-    _stepMs;
-    _bumpEvery;
-    /* ---- live state ---- */
-    _curStamp;
-    _index;
-    _ws = null;
-    _path = null;
-    _bytes = 0;
-    _timer = null;
-    _bumpTimer = null;
-    _ended = false;
-    _tail = Promise.resolve();
-    _warnedBackward = false;
-    _audit;
-    constructor(opts = {}) {
-        super(opts.highWaterMark ? { highWaterMark: opts.highWaterMark } : {});
-        const filename = opts.filename;
-        if (typeof filename !== "string" || !filename.includes("%DATE%")) {
-            throw new Error("opts.filename must contain '%DATE%' (e.g. 'logs/app-%DATE%.log')");
-        }
-        this.tz = opts.tz || "UTC";
-        getDtf(this.tz); // validate early, fail fast
-        this.template = path.basename(filename);
-        this.dir = path.dirname(filename);
-        this.datePattern = opts.datePattern || "YYYY-MM-DD";
-        this.zippedArchive = !!opts.zippedArchive;
-        this.maxSize = parseSize(opts.maxSize ?? 0);
-        this.maxFiles = parseMaxFiles(opts.maxFiles);
-        this.maxTotalSize = parseSize(opts.maxTotalSize ?? 0);
-        this.freq = parseFrequency(opts.frequency);
-        this.unrefTimers = !!opts.unrefTimers;
-        this._offsetMs = parseClockOffset(opts.addHours);
-        this._stepMs = parseClockStep(opts.addHoursEveryMin);
-        this._bumpEvery = Math.max(50, opts.clockStepIntervalMs ?? BUMP_DEFAULT_MS);
-        // compression + seal hook
-        this._compressionLevel = Math.min(9, Math.max(0, opts.compressionLevel ?? 6));
-        this._onSeal = opts.onSeal;
-        this._sealHookTimeoutMs = Math.max(0, opts.sealHookTimeoutMs ?? 30_000);
-        /* Split "prefix-%DATE%mid.ext" → pieces so indices land BETWEEN the
-           stamp and the extension: prefix-STAMP.N.ext                       */
-        const li = this.template.indexOf("%DATE%");
-        const rest = this.template.slice(li + "%DATE%".length);
-        const dot = rest.lastIndexOf(".");
-        this._tL = this.template.slice(0, li);
-        this._tMid = dot >= 0 ? rest.slice(0, dot) : "";
-        this._tExt = dot >= 0 ? rest.slice(dot) : "";
-        this._rxFor = (stampSrc) => new RegExp("^" +
-            escRe(this._tL) + stampSrc + escRe(this._tMid) +
-            "(?:\\.(\\d+))?" + escRe(this._tExt) + "(?:\\.gz)?$");
-        this._rxActive = this._rxFor("[^.]+");
-        this._auditEnabled = opts.audit !== false;
-        const stem = (this._tL.replace(/[^\w.-]+/g, "") || "log")
-            .replace(/^[-.]+|[-.]+$/g, "");
-        this._auditPath = path.join(this.dir, opts.auditFile || `${stem}_audit.json`);
-        // stable "current" pointer target
-        this._symlinkPath = opts.symlink
-            ? path.join(this.dir, typeof opts.symlink === "string"
-                ? opts.symlink
-                : `${stem}-current.log`)
-            : null;
-        fs.mkdirSync(this.dir, { recursive: true });
-        this._curStamp = this._stampNow();
-        this._audit = emptyAudit(this._tL, this._tExt, this.datePattern, this.tz);
-        const hadAudit = this._auditEnabled && this._loadAudit();
-        this._index = this._recoverIndexFor(this._curStamp);
-        const aiBoot = this._audit.activeIndex;
-        if (hadAudit && aiBoot !== null && this._audit.activeStamp === this._curStamp) {
-            this._index = Math.max(this._index, aiBoot);
-        }
-        if (this._offsetMs !== 0 || this._stepMs !== 0) {
-            process.nextTick(() => this.emit("clock", {
-                addHours: opts.addHours ?? undefined,
-                addHoursEveryMin: opts.addHoursEveryMin ?? undefined,
-                offsetMs: this._offsetMs,
-            }));
-        }
-        // warn when frequency is finer than the datePattern tokens
-        process.nextTick(() => {
-            const warn = (m) => this.emit("warn", new Error(m));
-            if (this.freq.type === "interval") {
-                if (this.freq.ms < 86_400_000 && !this.datePattern.includes("HH")) {
-                    warn(`frequency "${opts.frequency}" needs HH in datePattern — ` +
-                        "segments would collapse onto one filename");
-                }
-                if (this.freq.ms < 60_000 && !this.datePattern.includes("mm")) {
-                    warn(`frequency "${opts.frequency}" needs mm in datePattern`);
-                }
-            }
-            else if (!this.datePattern.includes("DD")) {
-                warn("daily frequency needs DD in datePattern");
-            }
-        });
-        /* Boot housekeeping is job #1 of the serial queue — chained HERE in the
-           constructor so it deterministically precedes any write job: zombie
-           demotion sees `_path === null`, gzip repair cannot race a reopen.  */
-        this._job(async () => {
-            // disk-driven, audit-independent (runs even with audit:false)
-            await this._sealOrphanedPastStamps();
-            if (this._auditEnabled) {
-                this._demoteZombieActives();
-                this._reconcileWithDisk();
-                await this._repairInterruptedGzips();
-                this._aevent("boot", { stamp: this._curStamp, index: this._index });
-                this._saveAudit();
-            }
-            if (this.maxFiles || this.maxTotalSize > 0)
-                this._retire(); // budget policy also gates
-        }).catch(() => { });
-        this._armTimer();
-        this._armBump();
-        this.once("close", () => {
-            this._stopTimer();
-            this._stopBump();
-        });
-    }
-    on(event, listener) {
-        return super.on(event, listener);
-    }
-    once(event, listener) {
-        return super.once(event, listener);
-    }
-    emit(event, ...args) {
-        return super.emit(event, ...args);
-    }
-    /* ==================================================================
-     * Public API
-     * ================================================================ */
-    /** Absolute path of the segment currently written; `null` until first write. */
-    get filename() {
-        return this._path;
-    }
-    /** Index of the active segment within the current period. */
-    get currentIndex() {
-        return this._index;
-    }
-    /** Force an immediate rotation and resolve when the next slot is staged. */
-    rotateNow() {
-        return this._job(() => this._rotate("manual"));
-    }
-    /**
-     * Apply ONE virtual-clock tick immediately (bypasses the interval timer
-     * for deterministic tests). Crossing into a new period triggers the same
-     * archive flow as a real midnight roll.
-     */
-    advanceClock() {
-        return this._job(() => this._applyBump());
-    }
-    /**
-     * Every family file on disk, oldest stamp first.
-     * Disk is truth: untracked files are reported with state "untracked".
-     */
-    listSegments() {
-        const rx = new RegExp("^" + escRe(this._tL) + "(.+?)" + escRe(this._tMid) +
-            "(?:\\.(\\d+))?" + escRe(this._tExt) + "(?:\\.gz)?$");
-        const skip = this._symlinkPath && path.basename(this._symlinkPath);
-        const out = [];
-        let names = [];
-        try {
-            names = fs.readdirSync(this.dir);
-        }
-        catch {
-            return out;
-        }
-        for (const n of names) {
-            if (n === skip)
-                continue;
-            const m = rx.exec(n);
-            if (!m)
-                continue;
-            const rec = this._audit.files[n];
-            out.push({
-                file: path.join(this.dir, n),
-                stamp: m[1],
-                index: m[2] ? Number.parseInt(m[2], 10) : 0,
-                gzipped: n.endsWith(".gz"),
-                bytes: statSizeSafe(path.join(this.dir, n)),
-                state: rec?.state ?? "untracked",
-                openedAt: rec?.openedAt,
-                archivedAt: rec?.archivedAt,
-            });
-        }
-        out.sort((a, b) => a.stamp.localeCompare(b.stamp) || a.index - b.index);
-        return out;
-    }
-    /**
-     * Health-check snapshot for dashboards and support triage.
-     */
-    stats() {
-        const segs = this.listSegments();
-        return {
-            dir: this.dir,
-            currentStamp: this._curStamp,
-            activeFile: this._path,
-            activeIndex: this._index,
-            segments: segs.length,
-            archived: segs.filter((s) => s.gzipped).length,
-            totalBytes: segs.reduce((sum, s) => sum + s.bytes, 0),
-            clockOffsetMs: this._offsetMs,
-            symlink: this._symlinkPath,
-        };
-    }
-    /* ==================================================================
-     * Writable contract
-     * ================================================================ */
-    _write(chunk, encoding, callback) {
-        if (this._ended) {
-            process.nextTick(callback, new Error("write after end"));
-            return;
-        }
-        const len = chunk.length;
-        this._job(async () => {
-            try {
-                // guarded roll (never rotates into a regressed stamp)
-                if (this._stampAdvanced(this._stampNow()))
-                    await this._rotate("time");
-                await this._ensureOpen();
-                if (this.maxSize > 0 &&
-                    this._bytes > 0 &&
-                    this._bytes + len > this.maxSize) {
-                    await this._rotate("size");
-                    await this._ensureOpen();
-                }
-                const ws = this._ws;
-                if (!ws)
-                    throw new Error("segment write stream not open");
-                await new Promise((resolve, reject) => ws.write(chunk, encoding, (e) => (e ? reject(e) : resolve())));
-                this._bytes += len;
-                callback();
-            }
-            catch (err) {
-                this.emit("error", err);
-                callback(err);
-            }
-        }).catch(() => { });
-    }
-    _final(callback) {
-        this._ended = true;
-        this._stopTimer();
-        this._stopBump();
-        this._job(async () => {
-            await endStream(this._ws);
-            const base = this._path && path.basename(this._path);
-            if (base && this._audit.files[base]) {
-                const rec = this._audit.files[base];
-                rec.state = "closed";
-                rec.closedAt = new Date().toISOString();
-                rec.bytes = statSizeSafe(this._path);
-                this._aevent("close", { file: base });
-                this._saveAudit();
-            }
-            this._ws = null;
-            this._path = null;
-        })
-            .catch(() => { })
-            .finally(() => callback());
-    }
-    destroy(...args) {
-        this._stopTimer();
-        this._stopBump();
-        return super.destroy(...args);
-    }
-    /* ==================================================================
-     * Serialisation — every mutating operation funnels through one queue
-     * so rotations/gzips/writes never interleave.
-     * ================================================================ */
-    _job(fn) {
-        const run = this._tail.then(fn, fn);
-        this._tail = run.catch(() => { });
-        return run;
-    }
-    _now() {
-        return Date.now() + this._offsetMs;
-    }
-    _stampNow(d = new Date(this._now())) {
-        return formatStamp(this.datePattern, partsIn(this.tz, d));
-    }
-    _resolveName(stamp, index) {
-        const base = path.join(this.dir, this._tL + stamp + this._tMid + this._tExt);
-        if (!index)
-            return base;
-        return /\.[^.]+$/.test(base)
-            ? base.replace(/\.[^.]+$/, `.${index}$&`)
-            : `${base}.${index}`;
-    }
-    /**
-     * true only when the period legally advanced. A regressed
-     * clock (NTP correction, manual change) never reopens a past family:
-     * writes continue in the current segment until real time catches up.
-     * Requires zero-padded datePattern tokens (documented assumption).
-     */
-    _stampAdvanced(stamp) {
-        if (stamp > this._curStamp)
-            return true;
-        if (stamp < this._curStamp && !this._warnedBackward) {
-            this._warnedBackward = true;
-            this.emit("warn", new Error(`clock moved backward (stamp ${stamp} < ${this._curStamp}); ` +
-                "keeping current segment until the clock catches up"));
-        }
-        return false;
-    }
-    /**
-     * Highest viable segment index for `stamp`.
-     * Disk is truth: resume a raw tail; start after sealed ones.
-     * The audit pointer (same stamp only) may only RAISE the result.
-     */
-    _recoverIndexFor(stamp) {
-        const rx = this._rxFor(escRe(stamp));
-        let maxAny = -1;
-        let maxRaw = -1;
-        let names = [];
-        try {
-            names = fs.readdirSync(this.dir);
-        }
-        catch {
-            /* unreadable dir → fresh series */
-        }
-        for (const n of names) {
-            const m = rx.exec(n);
-            if (!m)
-                continue;
-            const idx = m[1] ? Number.parseInt(m[1], 10) : 0;
-            if (idx > maxAny)
-                maxAny = idx;
-            if (!n.endsWith(".gz") && idx > maxRaw)
-                maxRaw = idx;
-        }
-        let idx = maxRaw >= 0 ? maxRaw : maxAny >= 0 ? maxAny + 1 : 0;
-        const ai = this._audit.activeIndex;
-        if (this._auditEnabled && ai !== null && this._audit.activeStamp === stamp) {
-            idx = Math.max(idx, ai);
-        }
-        return idx;
-    }
-    /**
-     * Atomically flip the "current" symlink to the active segment.
-     * tmp + rename so followers (`tail -f`, Filebeat) never observe a gap.
-     * Relative target keeps the link portable. Best-effort: filesystems
-     * denying symlinks warn once and disable the feature permanently.
-     */
-    _updateSymlink() {
-        const link = this._symlinkPath;
-        if (!link || !this._path)
-            return;
-        const tmp = `${link}.tmp`;
-        try {
-            try {
-                fs.unlinkSync(tmp);
-            }
-            catch { /* absent */ }
-            fs.symlinkSync(path.basename(this._path), tmp, "file");
-            fs.renameSync(tmp, link);
-        }
-        catch (e) {
-            this._symlinkPath = null;
-            this.emit("warn", new Error(`symlink unavailable ("${link}"): ${e.message} — continuing without it`));
-        }
-    }
-    /**
-     * Await the user's onSeal hook with a hard timeout. Result or
-     * failure degrades to `warn` — a wedged upload must never stall rotation.
-     * Called BEFORE retention so uploads finish before deletion.
-     */
-    async _runSealHook(raw, gz) {
-        const hook = this._onSeal;
-        if (!hook)
-            return;
-        let timer;
-        try {
-            await Promise.race([
-                Promise.resolve().then(() => hook({ raw, gz })),
-                new Promise((_, reject) => {
-                    timer = setTimeout(() => reject(new Error(`onSeal hook timed out after ${this._sealHookTimeoutMs}ms ` +
-                        `(${path.basename(gz ?? raw)})`)), this._sealHookTimeoutMs);
-                }),
-            ]);
-        }
-        catch (err) {
-            this.emit("warn", err);
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-    }
-    async _ensureOpen() {
-        if (this._ws)
-            return;
-        const p = this._resolveName(this._curStamp, this._index);
-        this._bytes = statSizeSafe(p);
-        const ws = fs.createWriteStream(p, { flags: "a" });
-        ws.on("error", (e) => this.emit("error", e));
-        this._ws = ws;
-        this._path = p;
-        this._updateSymlink(); // flip pointer on every open
-        if (this._auditEnabled) {
-            const base = path.basename(p);
-            // reopen = NEW incarnation. Never inherit lifecycle
-            // fields from the previous record (observed in the wild as
-            // abandonedAt < openedAt on reactivated segments).
-            this._audit.files[base] = {
-                index: this._index,
-                state: "active",
-                gzipPending: false,
-                openedAt: new Date().toISOString(),
-            };
-            this._setActivePointer(this._index);
-            this._aevent("open", {
-                file: base,
-                index: this._index,
-                resumedBytes: this._bytes,
-            });
-            this._saveAudit();
-        }
-        this.emit("open", p);
-    }
-    async _rotate(kind) {
-        const oldPath = this._path;
-        const oldWs = this._ws;
-        this._ws = null;
-        this._path = null;
-        this._bytes = 0;
-        let archive = null;
-        if (oldWs && oldPath) {
-            await endStream(oldWs);
-            const realBytes = statSizeSafe(oldPath);
-            const oldBase = path.basename(oldPath);
-            const rec = this._auditEnabled ? this._audit.files[oldBase] : undefined;
-            if (this.zippedArchive && realBytes > 0) {
-                archive = `${oldPath}.gz`;
-                /* Mark intent BEFORE compressing: crash mid-gzip becomes a
-                   repairable `gzipPending` flag instead of silent divergence.  */
-                if (rec) {
-                    rec.gzipPending = true;
-                    rec.bytes = realBytes;
-                    this._saveAudit();
-                }
-                const ok = await gzipMove(oldPath, archive, (e) => this.emit("warn", e), this._compressionLevel);
-                if (ok) {
-                    this._finishArchivedRecord(oldBase);
-                    await this._runSealHook(oldPath, archive);
-                }
-                else {
-                    if (rec) {
-                        rec.gzipPending = false;
-                        rec.state = "kept-raw";
-                    }
-                    this._aevent("gzip-failed", { file: oldBase });
-                    archive = null;
-                    await this._runSealHook(oldPath, null);
-                }
-            }
-            else if (realBytes === 0) {
-                // a concurrent writer may have archived this segment
-                // between our last stat and now — adopt its artifact instead of
-                // recording a false `drop-empty` that orphans the .gz.
-                const adoptedGz = `${oldPath}.gz`;
-                if (existsSafe(adoptedGz)) {
-                    this._finishArchivedRecord(oldBase);
-                    archive = adoptedGz;
-                    await this._runSealHook(oldPath, adoptedGz);
-                }
-                else {
-                    try {
-                        fs.unlinkSync(oldPath);
-                    }
-                    catch {
-                        /* already gone */
-                    }
-                    if (rec)
-                        delete this._audit.files[oldBase];
-                    this._aevent("drop-empty", { file: oldBase });
-                }
-            }
-            else if (realBytes > 0) {
-                // uncompressed seal (zippedArchive off): still notify sealers
-                if (rec) {
-                    rec.state = "sealed";
-                    rec.bytes = realBytes;
-                }
-                await this._runSealHook(oldPath, null);
-            }
-        }
-        let stamp = this._stampNow();
-        // a rotation itself must never move the series backward
-        // (covers rotateNow()/interval/size paths the upstream guards miss)
-        if (stamp < this._curStamp) {
-            if (!this._warnedBackward) {
-                this._warnedBackward = true;
-                this.emit("warn", new Error(`clock moved backward (stamp ${stamp} < ${this._curStamp}); ` +
-                    "rotation clamped to the current period"));
-            }
-            stamp = this._curStamp;
-        }
-        const newPeriod = stamp !== this._curStamp;
-        this._curStamp = stamp;
-        /* Never blind-reset to 0 — recover what THIS stamp already owns. */
-        this._index =
-            newPeriod || kind === "time"
-                ? this._recoverIndexFor(stamp)
-                : this._index + 1;
-        this._bytes = 0;
-        if (this._auditEnabled) {
-            this._setActivePointer(this._index);
-            this._aevent("rotate", { reason: kind, nextIndex: this._index, stamp });
-            this._saveAudit();
-        }
-        if (kind === "time" || kind === "manual")
-            this._armTimer();
-        if (oldPath) {
-            this.emit("rotated", {
-                reason: kind,
-                oldFile: oldPath,
-                archive,
-                newFile: this._resolveName(stamp, this._index),
-            });
-        }
-        this._retire();
-    }
-    /* ==================================================================
-     * Timers
-     * ================================================================ */
-    _hasContent() {
-        return this._ws
-            ? this._bytes > 0 || statSizeSafe(this._path) > 0
-            : !!(this._path && statSizeSafe(this._path) > 0);
-    }
-    _armTimer() {
-        this._stopTimer();
-        if (this._ended)
-            return;
-        const now = this._now();
-        const next = this.freq.type === "daily"
-            ? nextMidnight(this.tz, now)
-            : nextAligned(now, this.freq.ms);
-        // anti-spin. A backward clock can put the computed
-        // boundary in the past; poll gently instead of firing every 100 ms.
-        const delta = next - this._now();
-        const delay = delta < 0 ? TIMER_POLL_MS : Math.max(100, delta);
-        this._timer = setTimeout(() => {
-            this._job(async () => {
-                const stamp = this._stampNow();
-                if (this.freq.type !== "daily") {
-                    /* interval rotation is schedule-based; runs regardless of
-                       stamp movement */
-                    if (this._hasContent())
-                        await this._rotate("time");
-                }
-                else if (this._stampAdvanced(stamp)) {
-                    // guarded daily branch
-                    if (this._hasContent()) {
-                        await this._rotate("time");
-                    }
-                    else {
-                        /* idle boundary slide — no file created for empty days */
-                        this._curStamp = stamp;
-                        this._index = this._recoverIndexFor(stamp);
-                        if (this._auditEnabled) {
-                            this._setActivePointer(this._index);
-                            this._aevent("period", { stamp });
-                            this._saveAudit();
-                        }
-                        this.emit("period", stamp);
-                    }
-                }
-                /* stamp regressed or unchanged → keep current segment, re-arm */
-                this._armTimer();
-            }).catch(() => { });
-        }, delay);
-        if (this.unrefTimers)
-            this._timer.unref();
-    }
-    _armBump() {
-        this._stopBump();
-        if (!this._stepMs || this._ended)
-            return;
-        this._bumpTimer = setInterval(() => this._job(() => this._applyBump()).catch(() => { }), this._bumpEvery);
-        if (this.unrefTimers)
-            this._bumpTimer.unref();
-    }
-    _stopBump() {
-        if (this._bumpTimer) {
-            clearInterval(this._bumpTimer);
-            this._bumpTimer = null;
-        }
-    }
-    async _applyBump() {
-        if (this._ended)
-            return;
-        this._offsetMs += this._stepMs;
-        this._armTimer();
-        const stamp = this._stampNow();
-        // guarded crossing (virtual clock can't roll backward either)
-        if (this._stampAdvanced(stamp)) {
-            if (this._hasContent()) {
-                await this._rotate("time");
-            }
-            else {
-                this._curStamp = stamp;
-                this._index = this._recoverIndexFor(stamp);
-                if (this._auditEnabled) {
-                    this._setActivePointer(this._index);
-                    this._aevent("period", { stamp, virtual: true });
-                }
-                this.emit("period", stamp);
-            }
-        }
-        if (this._auditEnabled) {
-            this._aevent("clock-step", {
-                addedMsPerMin: this._stepMs,
-                offsetMs: this._offsetMs,
-                stamp,
-            });
-            this._saveAudit();
-        }
-    }
-    _stopTimer() {
-        if (this._timer) {
-            clearTimeout(this._timer);
-            this._timer = null;
-        }
-    }
-    /* ==================================================================
-     * Audit manifest
-     * ================================================================ */
-    _loadAudit() {
-        let parsed;
-        try {
-            parsed = JSON.parse(fs.readFileSync(this._auditPath, "utf8"));
-        }
-        catch {
-            // unparseable manifest is quarantined too (was silently
-            // clobbered by the first save — caught by the quarantine test)
-            try {
-                fs.renameSync(this._auditPath, `${this._auditPath}.corrupt`);
-            }
-            catch {
-                /* ignore */
-            }
-            return false;
-        }
-        const j = parsed;
-        if (!j || j.version !== 1 || j.prefix !== this._tL || j.ext !== this._tExt) {
-            try {
-                fs.renameSync(this._auditPath, `${this._auditPath}.corrupt`);
-            }
-            catch {
-                /* ignore */
-            }
-            return false;
-        }
-        this._audit.createdAt = j.createdAt ?? new Date().toISOString();
-        this._audit.activeStamp =
-            typeof j.activeStamp === "string" ? j.activeStamp : null;
-        this._audit.activeIndex =
-            Number.isInteger(j.activeIndex) ? j.activeIndex : null;
-        this._audit.files =
-            j.files && typeof j.files === "object"
-                ? j.files
-                : {};
-        this._audit.events = Array.isArray(j.events)
-            ? j.events.slice(-AUDIT_MAX_EVENTS)
-            : [];
-        /* Detect another LIVE process on this family before clobbering it. */
-        const w = j.writer;
-        if (w &&
-            typeof w.bootId === "string" &&
-            w.bootId !== this._bootId &&
-            typeof w.heartbeat === "number" &&
-            Date.now() - w.heartbeat < HEARTBEAT_STALE_MS) {
-            const err = new Error(`concurrent writer detected (pid ${w.pid}, boot ${w.bootId}); ` +
-                "two processes share this log family and will race. " +
-                "If running 'node --watch', exclude the logs dir via --watch-path.");
-            this.emit("warn", err);
-            this._audit.events.push({
-                id: randomUUID(),
-                t: new Date().toISOString(),
-                type: "concurrent-writer",
-                otherPid: w.pid,
-                otherBoot: w.bootId,
-            });
-        }
-        return true;
-    }
-    _saveAudit() {
-        if (!this._auditEnabled)
-            return;
-        try {
-            this._pruneAuditFiles();
-            this._audit.updatedAt = new Date().toISOString();
-            this._audit.writer = {
-                pid: process.pid,
-                bootId: this._bootId,
-                heartbeat: Date.now(),
-            };
-            const tmp = `${this._auditPath}.tmp`;
-            fs.writeFileSync(tmp, JSON.stringify(this._audit, null, 1));
-            fs.renameSync(tmp, this._auditPath);
-        }
-        catch (e) {
-            this.emit("warn", e);
-        }
-    }
-    _pruneAuditFiles() {
-        const files = this._audit.files;
-        const keys = Object.keys(files);
-        if (keys.length <= AUDIT_MAX_FILES)
-            return;
-        const activeBase = this._path && path.basename(this._path);
-        const lastTouch = (r) => r.archivedAt ?? r.closedAt ?? r.abandonedAt ?? r.openedAt ?? "";
-        const stale = keys
-            .filter((k) => k !== activeBase && files[k].state !== "active")
-            .sort((a, b) => lastTouch(files[a]).localeCompare(lastTouch(files[b])));
-        const excess = keys.length - AUDIT_MAX_FILES + 50;
-        for (const key of stale.slice(0, excess))
-            delete files[key];
-    }
-    _aevent(type, extra = {}) {
-        if (!this._auditEnabled)
-            return;
-        const events = this._audit.events;
-        events.push({ id: randomUUID(), t: new Date().toISOString(), type, ...extra });
-        if (events.length > AUDIT_MAX_EVENTS) {
-            events.splice(0, events.length - AUDIT_MAX_EVENTS);
-        }
-    }
-    _setActivePointer(index) {
-        this._audit.activeStamp = this._curStamp;
-        this._audit.activeIndex = index;
-    }
-    /** Records left `active` by dead processes → `abandoned`. */
-    _demoteZombieActives() {
-        const activeBase = this._path && path.basename(this._path);
-        for (const [name, rec] of Object.entries(this._audit.files)) {
-            if (rec.state === "active" && name !== activeBase) {
-                rec.state = "abandoned";
-                rec.abandonedAt = new Date().toISOString();
-                this._aevent("abandon", { file: name });
-            }
-        }
-    }
-    /** Heal audit-vs-disk divergence after crashes / external tampering. */
-    _reconcileWithDisk() {
-        for (const name of Object.keys(this._audit.files)) {
-            const rec = this._audit.files[name];
-            if (rec.gzipPending)
-                continue; // handled by the repair pass
-            if (name.endsWith(".gz")) {
-                const gzExists = existsSafe(path.join(this.dir, name));
-                const rawName = name.slice(0, -3);
-                const rawExists = existsSafe(path.join(this.dir, rawName));
-                if (gzExists)
-                    continue;
-                if (rawExists) {
-                    delete this._audit.files[name];
-                    this._audit.files[rawName] = { ...rec, state: "sealed" };
-                    this._aevent("archive-regressed", { file: name, backTo: rawName });
-                    this.emit("warn", new Error(`archive ${name} missing but raw ${rawName} exists`));
-                    continue;
-                }
-                this._aevent("vanished", { file: name });
-                delete this._audit.files[name];
-                continue;
-            }
-            const rawExists = existsSafe(path.join(this.dir, name));
-            const gzExists = existsSafe(path.join(this.dir, `${name}.gz`));
-            if (rawExists)
-                continue;
-            if (gzExists) {
-                this._finishArchivedRecord(name, true); // unlink was interrupted
-                continue;
-            }
-            this._aevent("vanished", { file: name });
-            delete this._audit.files[name];
-        }
-    }
-    /**
-     * DISK-DRIVEN seal. Seal raw segments whose period has
-     * already passed (crash near midnight, virtual-clock leftovers,
-     * untracked/pruned files). Iterates the DIRECTORY, not the manifest:
-     * the filesystem is the source of truth; the manifest is an index.
-     */
-    async _sealOrphanedPastStamps() {
-        if (!this.zippedArchive)
-            return;
-        const stampRx = new RegExp("^" + escRe(this._tL) + "(.+?)" + escRe(this._tMid) +
-            "(?:\\.\\d+)?" + escRe(this._tExt) + "(?:\\.gz)?$");
-        let names = [];
-        try {
-            names = fs.readdirSync(this.dir);
-        }
-        catch {
-            return;
-        }
-        for (const name of names) {
-            if (name.endsWith(".gz"))
-                continue;
-            if (name === (this._path && path.basename(this._path)))
-                continue;
-            const stamp = stampRx.exec(name)?.[1];
-            // lexicographic compare is safe for zero-padded patterns (YYYY-MM-DD…);
-            // also guards the current stamp and anything future-dated
-            if (!stamp || stamp >= this._curStamp)
-                continue;
-            const full = path.join(this.dir, name);
-            if (!existsSafe(full) || statSizeSafe(full) === 0)
-                continue;
-            const gzName = `${full}.gz`;
-            const ok = await gzipMove(full, gzName, (e) => this.emit("warn", e), this._compressionLevel);
-            if (!ok)
-                continue;
-            if (this._auditEnabled && this._audit.files[name]) {
-                // tracked → re-key record name → name.gz (emits archive + journal)
-                this._finishArchivedRecord(name, true);
-            }
-            else {
-                // untracked → record it fresh so future reconciles see truth
-                if (this._auditEnabled) {
-                    this._audit.files[gzName] = {
-                        state: "archived",
-                        gzipPending: false,
-                        archivedAt: new Date().toISOString(),
-                    };
-                    this._aevent("seal-past", { file: gzName });
-                }
-                this.emit("archive", gzName);
-            }
-            await this._runSealHook(full, gzName);
-        }
-    }
-    async _repairInterruptedGzips() {
-        for (const [name, rec] of Object.entries(this._audit.files)) {
-            if (!rec.gzipPending)
-                continue;
-            const src = path.join(this.dir, name);
-            const dst = `${src}.gz`;
-            if (!existsSafe(src)) {
-                rec.gzipPending = false;
-                rec.state = "lost";
-                this._aevent("gzip-lost", { file: name });
-                continue;
-            }
-            if (existsSafe(dst)) {
-                try {
-                    fs.unlinkSync(src);
-                }
-                catch {
-                    /* ignore */
-                }
-                this._finishArchivedRecord(name, true);
-                await this._runSealHook(src, dst);
-                continue;
-            }
-            const ok = await gzipMove(src, dst, (e) => this.emit("warn", e), this._compressionLevel);
-            if (ok) {
-                this._finishArchivedRecord(name, true);
-                await this._runSealHook(src, dst);
-            }
-            else {
-                rec.gzipPending = false;
-                rec.state = "kept-raw";
-                this._aevent("gzip-failed", { file: name });
-            }
-        }
-    }
-    /** Seal a record; re-key `name` → `name.gz` so scans stop ghosting. */
-    _finishArchivedRecord(rawName, repaired = false) {
-        const rec = this._audit.files[rawName];
-        if (!rec)
-            return;
-        rec.gzipPending = false;
-        rec.state = "archived";
-        rec.archivedAt = new Date().toISOString();
-        if (rawName.endsWith(".gz")) {
-            this.emit("archive", path.join(this.dir, rawName));
-            this._aevent("archive", { file: rawName, ...(repaired && { repaired }) });
-            return;
-        }
-        const gzName = `${rawName}.gz`;
-        delete this._audit.files[rawName];
-        this._audit.files[gzName] = rec;
-        this.emit("archive", path.join(this.dir, gzName));
-        this._aevent("archive", { file: gzName, ...(repaired && { repaired }) });
-    }
-    /* ==================================================================
-     * Retention
-     * ================================================================ */
-    async _retire() {
-        const policy = this.maxFiles;
-        if (!policy && this.maxTotalSize <= 0)
-            return; // budget gates too
-        const activeBase = this._path && path.basename(this._path);
-        const activeStem = activeBase?.replace(/(?:\.\d+)?(?:\.log|)(?:\.gz)?$/, "");
-        const reserved = [
-            path.basename(this._auditPath),
-            `${path.basename(this._auditPath)}.tmp`,
-            `${path.basename(this._auditPath)}.corrupt`,
-            // never eat the "current" pointer (or its tmp)
-            ...(this._symlinkPath
-                ? [path.basename(this._symlinkPath),
-                    `${path.basename(this._symlinkPath)}.tmp`]
-                : []),
-        ];
-        try {
-            const dirEntries = await fs.promises.readdir(this.dir);
-            const candidates = dirEntries.filter((n) => this._rxActive.test(n) &&
-                n !== activeBase &&
-                !(activeStem && n.startsWith(activeStem)) &&
-                !reserved.includes(n));
-            const stats = [];
-            for (const name of candidates) {
-                const full = path.join(this.dir, name);
-                try {
-                    const st = await fs.promises.stat(full);
-                    stats.push({ full, mtimeMs: st.mtimeMs, size: st.size }); // size
-                }
-                catch {
-                    /* raced deletion */
-                }
-            }
-            stats.sort((a, b) => a.mtimeMs - b.mtimeMs); // oldest first
-            const kill = new Set();
-            if (policy?.days != null) {
-                const cutoff = this._now() - policy.days * 86_400_000;
-                for (const f of stats)
-                    if (f.mtimeMs < cutoff)
-                        kill.add(f.full);
-            }
-            if (policy?.count != null) {
-                const survivors = stats.filter((f) => !kill.has(f.full));
-                const excessCount = survivors.length - policy.count;
-                for (let i = 0; i < excessCount; i++)
-                    kill.add(survivors[i].full);
-            }
-            // byte budget — delete OLDEST until under budget.
-            // The active segment is never a candidate, so only archives count.
-            if (this.maxTotalSize > 0) {
-                const survivors = stats.filter((f) => !kill.has(f.full)); // oldest→newest
-                let total = survivors.reduce((sum, f) => sum + f.size, 0);
-                let i = 0;
-                while (total > this.maxTotalSize && i < survivors.length) {
-                    kill.add(survivors[i].full);
-                    total -= survivors[i].size;
-                    i++;
-                }
-            }
-            if (kill.size === 0)
-                return;
-            for (const file of kill) {
-                await fs.promises.unlink(file).catch(() => { });
-                if (this._auditEnabled) {
-                    delete this._audit.files[path.basename(file)];
-                    this._aevent("deleted", { file: path.basename(file) });
-                }
-                this.emit("deleted", file);
-            }
-            this._saveAudit();
-        }
-        catch (e) {
-            this.emit("warn", e);
-        }
-    }
-}
-/**
- * Convenience factory mirroring common rotator APIs.
- *
- * @example
- * const log = createStream({ filename: "logs/app-%DATE%.log" });
- */
-function createStream(options) {
-    return new RotateFileStream(options);
-}
-
-const registry = new Set();
-let installed = false;
-let inProgress = false;
-/**
- * Register streams for graceful shutdown: on SIGINT/SIGTERM every
- * registered stream is ended — flushing buffered writes and finishing the
- * audit manifest — before the process exits, with a hard deadline.
- *
- * Safe to call multiple times: process listeners install once, streams
- * accumulate in the registry.
- *
- * Returns `flush()`, the same graceful end WITHOUT exiting — for tests
- * and custom signal handling.
- *
- * @example
- * const flush = installShutdown(logStream);
- * process.on("exit", () => { void flush(); });
- */
-function installShutdown(streams, opts = {}) {
-    const list = Array.isArray(streams) ? streams : [streams];
-    for (const s of list)
-        registry.add(s);
-    if (!installed) {
-        installed = true;
-        const timeoutMs = opts.timeoutMs ?? 5_000;
-        const code = opts.code ?? 0;
-        for (const sig of opts.signals ?? ["SIGINT", "SIGTERM"]) {
-            process.on(sig, () => {
-                void flushAll(timeoutMs).finally(() => process.exit(code));
-            });
-        }
-    }
-    return async () => {
-        // flush FIRST — flushAll() drains the registry, so unregistering
-        // before flushing would flush nothing (caught by the shutdown test)
-        await flushAll(opts.timeoutMs ?? 5_000);
-        for (const s of list)
-            registry.delete(s);
-    };
-}
-/**
- * End every registered stream (flush buffered writes) with a deadline.
- * Does NOT exit the process. Double-ending an already-ended stream is
- * harmless — the error lands in the ignored callback.
- */
-async function flushAll(timeoutMs = 5_000) {
-    if (inProgress)
-        return;
-    inProgress = true;
-    const deadline = setTimeout(() => process.exit(1), timeoutMs);
-    deadline.unref();
-    try {
-        await Promise.allSettled([...registry].map((s) => new Promise((res) => s.end(() => res()))));
-    }
-    finally {
-        clearTimeout(deadline);
-        inProgress = false;
-    }
-}
-
-export { RotateFileStream, createStream, flushAll, installShutdown };
+/*! logroller v3.0.0 | MIT License */
+export{R as RotateFileStream,c as createStream}from"./rotate-file-stream.esm.js";import"node:crypto";import"node:fs";import"node:path";import"node:stream";import"node:zlib";import"node:stream/promises";const e=new Set;let t=!1,o=null;function r(o,r={}){const n=Array.isArray(o)?o:[o];for(const t of n)e.add(t);if(!t){t=!0;const e=r.timeoutMs??5e3,o=r.code??0;for(const t of r.signals??["SIGINT","SIGTERM"])process.on(t,()=>{s(e).then(e=>process.exit(e?o:1))})}return async()=>{await s(r.timeoutMs??5e3);for(const t of n)e.delete(t)}}function s(t=5e3){return o??=(async()=>{let r;try{const o=Promise.allSettled([...e].map(e=>new Promise(t=>{e.once("close",t),e.end(()=>t()),e.destroyed&&t()}))).then(()=>!0),s=new Promise(e=>{r=setTimeout(()=>e(!1),t),r.unref()});return await Promise.race([o,s])}finally{clearTimeout(r);for(const t of e)(t.writableFinished||t.destroyed)&&e.delete(t);o=null}})(),o}export{s as flushAll,r as installShutdown};