@cello-protocol/daemon 0.0.225 → 0.0.227

package/dist/line-lcs.d.ts

@@ -1,51 +0,0 @@
-/**
- * The line LCS, shared by the write path (DOD-DOC-WRITE-1) and the diff surfaces
- * (DOD-DOC-NOTIFY-1).
- *
- * One implementation, deliberately. These two need to agree about what changed — the write path
- * publishes hunks and the diff surfaces describe them to an operator — and two hand-rolled diffs
- * that must agree are two things to keep in step, which is how they stop agreeing.
- *
- * ── WHY A REAL LCS AND NOT A PREFIX/SUFFIX TRIM ───────────────────────────────────────────────
- *
- * Measured twice, in two units, with the same result. A prefix/suffix trim is correct only when
- * exactly one contiguous region changed; the moment a line is INSERTED or DELETED, everything after
- * it shifts and a naive positional walk reports the whole remainder as rewritten:
- *
- *     inserting one line at the top of a 3-line file  ->  +4 -3, one range covering the file
- *
- * In the write path (WRITE-1) that published text the file did not contain — four of six ordinary
- * markdown edits. In the diff surfaces (NOTIFY-1) it made the overlap flag permanently true, which
- * is worse than useless: the flag exists so an agent can tell whether the peer touched what it
- * touched, and one that always says yes trains the agent to ignore it.
- *
- * A real LCS is also what emits SEPARATE runs for separated edits. One span from the first change
- * to the last would delete and re-insert everything between them as new operations, resurrecting
- * text a peer concurrently deleted — and under publish-on-intent, multi-edit publishes are the
- * modal case.
- */
-/** Above this many lines the table is not worth building — the caller falls back and says so. */
-export declare const LCS_LINE_LIMIT = 4000;
-/**
- * A contiguous run of changed lines, as HALF-OPEN index ranges into each side.
- *
- * `aStart === aEnd` is a pure insertion; `bStart === bEnd` is a pure deletion. Half-open because
- * the empty range then has an unambiguous spelling, which a closed range does not.
- */
-export interface LineRun {
-    aStart: number;
-    aEnd: number;
-    bStart: number;
-    bEnd: number;
-}
-/** Lines carrying their own trailing newline; the last line carries none. */
-export declare function toChunks(text: string): string[];
-/**
- * The runs of changed lines between two chunk arrays.
- *
- * Returns `null` when either side exceeds `LCS_LINE_LIMIT` — the quadratic table on a document
- * that large is the wrong kind of thorough, and a caller that silently degraded instead of being
- * told would report a whole-file rewrite as if it were a measurement.
- */
-export declare function lineRuns(a: readonly string[], b: readonly string[]): LineRun[] | null;
-//# sourceMappingURL=line-lcs.d.ts.map

package/dist/line-lcs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"line-lcs.d.ts","sourceRoot":"","sources":["../src/line-lcs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,iGAAiG;AACjG,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,6EAA6E;AAC7E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAG/C;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,EAAE,GAAG,IAAI,CA8BrF"}

package/dist/line-lcs.js

@@ -1,71 +0,0 @@
-/**
- * The line LCS, shared by the write path (DOD-DOC-WRITE-1) and the diff surfaces
- * (DOD-DOC-NOTIFY-1).
- *
- * One implementation, deliberately. These two need to agree about what changed — the write path
- * publishes hunks and the diff surfaces describe them to an operator — and two hand-rolled diffs
- * that must agree are two things to keep in step, which is how they stop agreeing.
- *
- * ── WHY A REAL LCS AND NOT A PREFIX/SUFFIX TRIM ───────────────────────────────────────────────
- *
- * Measured twice, in two units, with the same result. A prefix/suffix trim is correct only when
- * exactly one contiguous region changed; the moment a line is INSERTED or DELETED, everything after
- * it shifts and a naive positional walk reports the whole remainder as rewritten:
- *
- *     inserting one line at the top of a 3-line file  ->  +4 -3, one range covering the file
- *
- * In the write path (WRITE-1) that published text the file did not contain — four of six ordinary
- * markdown edits. In the diff surfaces (NOTIFY-1) it made the overlap flag permanently true, which
- * is worse than useless: the flag exists so an agent can tell whether the peer touched what it
- * touched, and one that always says yes trains the agent to ignore it.
- *
- * A real LCS is also what emits SEPARATE runs for separated edits. One span from the first change
- * to the last would delete and re-insert everything between them as new operations, resurrecting
- * text a peer concurrently deleted — and under publish-on-intent, multi-edit publishes are the
- * modal case.
- */
-/** Above this many lines the table is not worth building — the caller falls back and says so. */
-export const LCS_LINE_LIMIT = 4000;
-/** Lines carrying their own trailing newline; the last line carries none. */
-export function toChunks(text) {
-    const lines = text.split("\n");
-    return lines.map((line, index) => (index < lines.length - 1 ? `${line}\n` : line));
-}
-/**
- * The runs of changed lines between two chunk arrays.
- *
- * Returns `null` when either side exceeds `LCS_LINE_LIMIT` — the quadratic table on a document
- * that large is the wrong kind of thorough, and a caller that silently degraded instead of being
- * told would report a whole-file rewrite as if it were a measurement.
- */
-export function lineRuns(a, b) {
-    if (a.length > LCS_LINE_LIMIT || b.length > LCS_LINE_LIMIT)
-        return null;
-    const lcs = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
-    for (let i = a.length - 1; i >= 0; i--) {
-        for (let j = b.length - 1; j >= 0; j--) {
-            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
-        }
-    }
-    const runs = [];
-    let i = 0;
-    let j = 0;
-    while (i < a.length || j < b.length) {
-        if (i < a.length && j < b.length && a[i] === b[j]) {
-            i++;
-            j++;
-            continue;
-        }
-        const aStart = i;
-        const bStart = j;
-        while ((i < a.length || j < b.length) && !(i < a.length && j < b.length && a[i] === b[j])) {
-            if (j < b.length && (i === a.length || lcs[i][j + 1] >= lcs[i + 1][j]))
-                j++;
-            else
-                i++;
-        }
-        runs.push({ aStart, aEnd: i, bStart, bEnd: j });
-    }
-    return runs;
-}
-//# sourceMappingURL=line-lcs.js.map

package/dist/line-lcs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"line-lcs.js","sourceRoot":"","sources":["../src/line-lcs.ts"],"names":[],"mappings":"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"}

package/dist/lock-file.d.ts

@@ -1,39 +0,0 @@
-/**
- * Lock file management for the CELLO daemon.
- *
- * Pseudocode:
- * 1. acquireLock(path, content):
- *    - Write JSON content to path.tmp atomically
- *    - Rename path.tmp → path (atomic on POSIX)
- *    - Return true on success
- *
- * 2. readLock(path):
- *    - Read file, parse JSON
- *    - Validate shape: {pid: number, socketPath: string, version: string}
- *    - Return parsed content or null if missing/invalid
- *
- * 3. isProcessAlive(pid):
- *    - process.kill(pid, 0) — signal 0 checks existence without killing
- *    - Return true if no error thrown
- *
- * 4. removeLock(path):
- *    - Unlink the file, ignoring ENOENT
- */
-import type { LockFileContent, Logger } from "./types.js";
-export declare function readLock(lockPath: string): Promise<LockFileContent | null>;
-export declare function acquireLock(lockPath: string, content: LockFileContent): Promise<void>;
-export declare function removeLock(lockPath: string, logger: Logger): Promise<void>;
-/**
- * DOD-DAEMON-CLEANUP-1 (AC1) — remove the lock ONLY if it is still ours.
- *
- * An exiting daemon must not disarm a daemon it does not own. By the time we shut down, a DIFFERENT
- * daemon may have written this lock; deleting it would leave that healthy daemon unreachable
- * (`cello logout` reports "No daemon running") and the next `cello login` would spawn a third beside
- * it. That is the cascade — the obvious recovery action, killing the orphan, propagates the bug.
- *
- * `removeLock` (unconditional) is still correct for the CLI's stale-lock cleanup, where the lock
- * belongs to a process that is provably gone. It is NOT correct on the way out of a live daemon.
- */
-export declare function removeLockIfOwned(lockPath: string, ownPid: number, logger: Logger): Promise<void>;
-export declare function isProcessAlive(pid: number): boolean;
-//# sourceMappingURL=lock-file.d.ts.map

package/dist/lock-file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lock-file.d.ts","sourceRoot":"","sources":["../src/lock-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAG1D,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAwBhF;AAED,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAU3F;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhF;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAwBf;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOnD"}

package/dist/lock-file.js

@@ -1,120 +0,0 @@
-/**
- * Lock file management for the CELLO daemon.
- *
- * Pseudocode:
- * 1. acquireLock(path, content):
- *    - Write JSON content to path.tmp atomically
- *    - Rename path.tmp → path (atomic on POSIX)
- *    - Return true on success
- *
- * 2. readLock(path):
- *    - Read file, parse JSON
- *    - Validate shape: {pid: number, socketPath: string, version: string}
- *    - Return parsed content or null if missing/invalid
- *
- * 3. isProcessAlive(pid):
- *    - process.kill(pid, 0) — signal 0 checks existence without killing
- *    - Return true if no error thrown
- *
- * 4. removeLock(path):
- *    - Unlink the file, ignoring ENOENT
- */
-import { readFile, writeFile, rename, stat, unlink } from "node:fs/promises";
-import { extractErrorMessage } from "./error-message.js";
-export async function readLock(lockPath) {
-    let raw;
-    try {
-        raw = await readFile(lockPath, "utf-8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT") {
-            return null;
-        }
-        throw err;
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.pid !== "number" ||
-            typeof parsed.socketPath !== "string" ||
-            typeof parsed.version !== "string") {
-            return null;
-        }
-        return { pid: parsed.pid, socketPath: parsed.socketPath, version: parsed.version };
-    }
-    catch {
-        return null;
-    }
-}
-export async function acquireLock(lockPath, content) {
-    const tmpPath = lockPath + ".tmp";
-    const json = JSON.stringify(content, null, 2) + "\n";
-    await writeFile(tmpPath, json, { mode: 0o600 });
-    try {
-        await rename(tmpPath, lockPath);
-    }
-    catch (err) {
-        try {
-            await unlink(tmpPath);
-        }
-        catch { /* best-effort cleanup */ }
-        throw err;
-    }
-}
-export async function removeLock(lockPath, logger) {
-    try {
-        await unlink(lockPath);
-    }
-    catch (err) {
-        if (err.code !== "ENOENT") {
-            logger.warn("daemon.lock.remove.failed", {
-                lockPath,
-                error: extractErrorMessage(err),
-            });
-        }
-    }
-}
-/**
- * DOD-DAEMON-CLEANUP-1 (AC1) — remove the lock ONLY if it is still ours.
- *
- * An exiting daemon must not disarm a daemon it does not own. By the time we shut down, a DIFFERENT
- * daemon may have written this lock; deleting it would leave that healthy daemon unreachable
- * (`cello logout` reports "No daemon running") and the next `cello login` would spawn a third beside
- * it. That is the cascade — the obvious recovery action, killing the orphan, propagates the bug.
- *
- * `removeLock` (unconditional) is still correct for the CLI's stale-lock cleanup, where the lock
- * belongs to a process that is provably gone. It is NOT correct on the way out of a live daemon.
- */
-export async function removeLockIfOwned(lockPath, ownPid, logger) {
-    const lock = await readLock(lockPath);
-    if (lock === null) {
-        // readLock returns null for BOTH "absent" and "unparseable" — so this is the one place that
-        // cannot tell "nothing to do" from "something is wrong". Distinguish them: a lock file that
-        // exists but cannot be read (truncated by a full disk, a partial write) is left alone, because we
-        // cannot prove it is ours — but it is said out loud rather than passed over in silence.
-        try {
-            await stat(lockPath);
-            logger.warn("daemon.lock.unreadable", { ownPid, lockPath });
-        }
-        catch {
-            // Genuinely absent. Nothing to remove, nothing to report.
-        }
-        return;
-    }
-    if (lock.pid !== ownPid) {
-        // SI: a daemon that declines to remove a lock says so. Silence here is what made the live
-        // incident so hard to see.
-        logger.info("daemon.lock.not_ours", { ownPid, lockPid: lock.pid, lockPath });
-        return;
-    }
-    await removeLock(lockPath, logger);
-}
-export function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=lock-file.js.map

package/dist/lock-file.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lock-file.js","sourceRoot":"","sources":["../src/lock-file.ts"],"names":[],"mappings":"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"}

package/dist/log-collapse.d.ts

@@ -1,66 +0,0 @@
-import type { Logger } from "./types.js";
-/**
- * DOD-M15-LOGBOUND-1 part A — write a repeating log line ONCE, then count it.
- *
- * The file that produced this order was 180 MB and 469,065 lines. 168 MB of it — 95% — was a
- * single `session.key.announce.failed` line repeated 413,590 times, byte-identical apart from its
- * timestamp, from a retry that never gave up.
- *
- * **The disk was the smaller half.** That loop hid behind its own output for eleven hours. A file
- * that is 95% one sentence is not a diagnostic surface; it is a haystack the daemon builds around
- * its own needle, faster than anyone can read it.
- *
- * **This is the rule `045-REFUSALSTORM` applies to the operator's inbox, one layer down.** Same
- * idea in two places, not two mechanisms.
- *
- * ⚠️ **This makes a storm cheap. It does not make a storm correct.** The loops themselves are
- * fixed by `045-REFUSALSTORM` and `DOD-M15-KEYANNOUNCE-LOOP-1`; this unit must not be cited as
- * covering either.
- *
- * ## The gate is a RATE, not a count — and the first build got this wrong
- *
- * The obvious design suppresses everything after the first occurrence and re-reports at the 10th,
- * 100th, 1,000th. It was built that way, and review found two defects in it that matter more than
- * the bytes it saved:
- *
- * 1. **A bounded retry that failed three times printed one line.** Three is not a power of ten, so
- *    attempts two and three were dropped and nothing anywhere ever said they happened. An operator
- *    whose standing receiver cannot bind then reads one `session.node.create.failed` followed by
- *    `session.standing_receiver.dead`, and cannot tell a retry that ran from a retry that never
- *    fired — which is the first thing they would go and check.
- * 2. **A chronic failure went permanently silent.** A run never expired, so something failing once
- *    an hour reached its 10th occurrence on day one and was next written on day four. The daemon
- *    stopped reporting an ongoing failure precisely because it had been failing for a long time.
- *
- * So nothing is suppressed until a key is genuinely FLOODING: more than {@link STORM_BURST}
- * occurrences inside {@link STORM_WINDOW_MS}. Below that rate every line is written exactly as it
- * was before this unit existed. The measured storm ran at 4–17 lines/second and trips the gate on
- * its 21st line; an ordinary two-to-nine repeat never trips it at all, and neither does a slow
- * chronic failure — which is how both defects above stay fixed rather than traded against each
- * other.
- */
-/** Occurrences of one key inside one window that mean "this is a flood, not a repeat". */
-export declare const STORM_BURST = 20;
-/** The window the burst is measured over. Also the idle period that ENDS a storm. */
-export declare const STORM_WINDOW_MS = 10000;
-/**
- * Bound on the table. Without one, the thing that removes an unbounded log would itself be an
- * unbounded map — the same defect one layer further in.
- *
- * Eviction is least-recently-USED, and that is load-bearing rather than tidy. Plenty of events
- * carry a value unique to the occurrence — a fresh root hash, a content hash, a peer id — so in
- * ordinary operation the table is mostly keys that will never be seen again. Under
- * insertion-order eviction the one key the table exists to hold, the one being hit thousands of
- * times a second, is evicted on the same schedule as keys that are read once; the count resets and
- * the single number that made the storm diagnosable is destroyed. Under LRU a never-repeating key
- * is always the oldest and is always the first to go.
- */
-export declare const LOG_COLLAPSE_MAX_KEYS = 2048;
-/**
- * Wrap a logger so a FLOODING line is written once and then counted.
- *
- * Wrapping the composition root covers every call site at once, which is what makes this a
- * property of the daemon's logging rather than a discipline each call site has to remember.
- */
-export declare function createCollapsingLogger(sink: Logger, now?: () => number): Logger;
-//# sourceMappingURL=log-collapse.d.ts.map

package/dist/log-collapse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log-collapse.d.ts","sourceRoot":"","sources":["../src/log-collapse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,0FAA0F;AAC1F,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B,qFAAqF;AACrF,eAAO,MAAM,eAAe,QAAS,CAAC;AAEtC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC;AA0E1C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,MAAiB,GAAG,MAAM,CAyIzF"}

package/dist/log-collapse.js

@@ -1,244 +0,0 @@
-/**
- * DOD-M15-LOGBOUND-1 part A — write a repeating log line ONCE, then count it.
- *
- * The file that produced this order was 180 MB and 469,065 lines. 168 MB of it — 95% — was a
- * single `session.key.announce.failed` line repeated 413,590 times, byte-identical apart from its
- * timestamp, from a retry that never gave up.
- *
- * **The disk was the smaller half.** That loop hid behind its own output for eleven hours. A file
- * that is 95% one sentence is not a diagnostic surface; it is a haystack the daemon builds around
- * its own needle, faster than anyone can read it.
- *
- * **This is the rule `045-REFUSALSTORM` applies to the operator's inbox, one layer down.** Same
- * idea in two places, not two mechanisms.
- *
- * ⚠️ **This makes a storm cheap. It does not make a storm correct.** The loops themselves are
- * fixed by `045-REFUSALSTORM` and `DOD-M15-KEYANNOUNCE-LOOP-1`; this unit must not be cited as
- * covering either.
- *
- * ## The gate is a RATE, not a count — and the first build got this wrong
- *
- * The obvious design suppresses everything after the first occurrence and re-reports at the 10th,
- * 100th, 1,000th. It was built that way, and review found two defects in it that matter more than
- * the bytes it saved:
- *
- * 1. **A bounded retry that failed three times printed one line.** Three is not a power of ten, so
- *    attempts two and three were dropped and nothing anywhere ever said they happened. An operator
- *    whose standing receiver cannot bind then reads one `session.node.create.failed` followed by
- *    `session.standing_receiver.dead`, and cannot tell a retry that ran from a retry that never
- *    fired — which is the first thing they would go and check.
- * 2. **A chronic failure went permanently silent.** A run never expired, so something failing once
- *    an hour reached its 10th occurrence on day one and was next written on day four. The daemon
- *    stopped reporting an ongoing failure precisely because it had been failing for a long time.
- *
- * So nothing is suppressed until a key is genuinely FLOODING: more than {@link STORM_BURST}
- * occurrences inside {@link STORM_WINDOW_MS}. Below that rate every line is written exactly as it
- * was before this unit existed. The measured storm ran at 4–17 lines/second and trips the gate on
- * its 21st line; an ordinary two-to-nine repeat never trips it at all, and neither does a slow
- * chronic failure — which is how both defects above stay fixed rather than traded against each
- * other.
- */
-/** Occurrences of one key inside one window that mean "this is a flood, not a repeat". */
-export const STORM_BURST = 20;
-/** The window the burst is measured over. Also the idle period that ENDS a storm. */
-export const STORM_WINDOW_MS = 10_000;
-/**
- * Bound on the table. Without one, the thing that removes an unbounded log would itself be an
- * unbounded map — the same defect one layer further in.
- *
- * Eviction is least-recently-USED, and that is load-bearing rather than tidy. Plenty of events
- * carry a value unique to the occurrence — a fresh root hash, a content hash, a peer id — so in
- * ordinary operation the table is mostly keys that will never be seen again. Under
- * insertion-order eviction the one key the table exists to hold, the one being hit thousands of
- * times a second, is evicted on the same schedule as keys that are read once; the count resets and
- * the single number that made the storm diagnosable is destroyed. Under LRU a never-repeating key
- * is always the oldest and is always the first to go.
- */
-export const LOG_COLLAPSE_MAX_KEYS = 2048;
-/** Separator for key parts. A control character cannot appear in an event name or a field value. */
-const SEP = String.fromCharCode(31);
-/**
- * The collapse key.
- *
- * ⚠️ **IT MUST NOT BE LOOSER THAN event + session + reason**, and it is exactly that. Keying on the
- * event name alone would merge a hundred sessions failing once each into one line reading "x100" —
- * strictly worse than the noise this removes, because a fan-out is the shape you most need to see
- * and it would be reported as a repeat. The level is in the key too: the same event at `warn` and
- * at `error` is two facts.
- *
- * **And it is deliberately NOT the whole payload**, which is the second thing the first build got
- * wrong. Keying on every field looked tighter and therefore safer, and it is neither:
- *
- * - `session.key.announce.failed` — the very event this unit was written for — carries an `attempt`
- *   counter. Every attempt is a different payload, so a full-payload key collapses NOTHING on the
- *   one path that produced 168 MB. The historical storm only collapsed because the pre-fix bug
- *   pinned `attempt` at 1; the fix that made the retry chain correct is what would have defeated it.
- * - A loop minting a fresh key per iteration also churns the whole table at the rate it runs,
- *   evicting every other run in it.
- *
- * The cost of the looser key is paid elsewhere rather than ignored: because suppression is gated on
- * a RATE, a payload field that changes between occurrences is written in full at any ordinary rate,
- * and is only folded once the key is genuinely flooding — at which point a count and a rate are
- * more use than ten thousand individual values. Milestones republish the most recent payload, so
- * the newest values stay on the record.
- *
- * Returns `null` when the key cannot be built from what the call site passed. **Such a line does
- * not collapse at all** — losing the saving is correct where losing the distinction is not.
- */
-function collapseKey(level, event, ctx) {
-    const sessionId = ctx["sessionId"];
-    const reason = ctx["reason"];
-    if (typeof sessionId !== "string" && typeof reason !== "string")
-        return null;
-    return [level, event, String(sessionId ?? ""), String(reason ?? "")].join(SEP);
-}
-/** First occurrence, then the 10th, 100th, 1,000th — a power of ten. */
-function isMilestone(count) {
-    if (count === 1)
-        return true;
-    let n = count;
-    while (n % 10 === 0)
-        n /= 10;
-    return n === 1;
-}
-/**
- * Wrap a logger so a FLOODING line is written once and then counted.
- *
- * Wrapping the composition root covers every call site at once, which is what makes this a
- * property of the daemon's logging rather than a discipline each call site has to remember.
- */
-export function createCollapsingLogger(sink, now = Date.now) {
-    const runs = new Map();
-    /**
-     * Report a fold that has ended: how many lines it swallowed, and over how long.
-     *
-     * ⚠️ **THE WINDOW IS MEASURED TO THE LAST OCCURRENCE, NOT TO NOW**, and getting that wrong made
-     * this line state the opposite of what happened. A flood of 479 lines over 25 seconds — 19 a
-     * second — was reported as `repeatWindowMs: 21623950`, six hours, because the idle gap that
-     * proved the flood was over had already been folded into the elapsed time. An operator dividing
-     * those two numbers reads 1.3 an hour: a trickle, when it was the storm.
-     */
-    function closeRun(run) {
-        sink[run.level](run.event, {
-            ...run.lastCtx,
-            repeatedCount: run.suppressedCount,
-            repeatWindowMs: Math.max(0, run.lastAtMs - run.suppressStartMs),
-            repeatEnded: true,
-        });
-        run.suppressing = false;
-        run.suppressedCount = 0;
-    }
-    /**
-     * One amortised look at the oldest run per line written.
-     *
-     * Without it a fold that simply STOPS is never reported: the closing line is emitted by the
-     * key's own next occurrence, and a storm whose cause is fixed — or whose daemon is shut down —
-     * has no next occurrence. The measured 413,590-line storm would have ended on
-     * `repeatedCount: 100000`, understating itself fourfold, with nothing saying it had finished.
-     */
-    function sweepOldest(at, currentKey) {
-        const oldest = runs.entries().next();
-        if (oldest.done)
-            return;
-        const [key, run] = oldest.value;
-        if (key === currentKey)
-            return;
-        if (at - run.lastAtMs < STORM_WINDOW_MS)
-            return;
-        if (run.suppressing)
-            closeRun(run);
-        runs.delete(key);
-    }
-    function emit(level, event, ctx) {
-        const key = collapseKey(level, event, ctx);
-        if (key === null) {
-            sink[level](event, ctx);
-            return;
-        }
-        const at = now();
-        sweepOldest(at, key);
-        const existing = runs.get(key);
-        if (existing === undefined) {
-            if (runs.size >= LOG_COLLAPSE_MAX_KEYS) {
-                const oldest = runs.entries().next();
-                if (!oldest.done) {
-                    // Evicting a run mid-fold would take its total with it and restart the next occurrence
-                    // from one. Over-reporting is the safe direction; losing the count is not.
-                    if (oldest.value[1].suppressing)
-                        closeRun(oldest.value[1]);
-                    runs.delete(oldest.value[0]);
-                }
-            }
-            runs.set(key, {
-                level, event, windowStartMs: at, lastAtMs: at, windowCount: 1,
-                suppressing: false, suppressStartMs: 0, suppressedCount: 0, lastCtx: ctx,
-            });
-            sink[level](event, ctx);
-            return;
-        }
-        // Least-recently-USED: re-inserting moves this key to the young end of the eviction order.
-        runs.delete(key);
-        runs.set(key, existing);
-        /**
-         * A gap longer than a window means the flood has stopped — measured from the PREVIOUS
-         * occurrence, never from the window's own tally. Reading the tally was the first version of
-         * this and it could never end a storm: during one, the count carried over from the last
-         * window is high by definition, so the "has it died down" test was never true.
-         */
-        const idle = at - existing.lastAtMs >= STORM_WINDOW_MS;
-        if (idle) {
-            if (existing.suppressing)
-                closeRun(existing);
-            existing.windowStartMs = at;
-            existing.windowCount = 0;
-        }
-        else if (at - existing.windowStartMs >= STORM_WINDOW_MS) {
-            /**
-             * ⚠️ A FULL WINDOW PASSED WITH TRAFFIC — so re-test the RATE, do not just roll the window.
-             * Without this, `suppressing` latches: the only exit is a ten-second silence, so a retry
-             * that starts fast and backs off to anything under one line per ten seconds stays folded
-             * forever. Measured on the built module: 30 lines in 3 seconds trips the gate, and the next
-             * 1,200 occurrences spread over three hours produce three lines. That is the chronic-failure
-             * silence this redesign was written to remove, re-entered through a different door.
-             */
-            if (existing.suppressing && existing.windowCount <= STORM_BURST)
-                closeRun(existing);
-            existing.windowStartMs = at;
-            existing.windowCount = 0;
-        }
-        existing.lastAtMs = at;
-        existing.windowCount += 1;
-        if (existing.suppressing) {
-            existing.lastCtx = ctx;
-            existing.suppressedCount += 1;
-            // The 1st suppressed occurrence is not a milestone worth printing — the line that tripped
-            // the gate, immediately above it, already said the fold had started.
-            if (existing.suppressedCount === 1 || !isMilestone(existing.suppressedCount))
-                return;
-            sink[level](event, {
-                ...ctx,
-                repeatedCount: existing.suppressedCount,
-                repeatWindowMs: Math.max(0, at - existing.suppressStartMs),
-            });
-            return;
-        }
-        if (existing.windowCount > STORM_BURST) {
-            // The gate trips. This line is still written in full, and says that the ones behind it
-            // will not be — an operator should never have to infer that lines are being dropped.
-            existing.suppressing = true;
-            existing.suppressStartMs = at;
-            existing.suppressedCount = 0;
-            existing.lastCtx = ctx;
-            sink[level](event, { ...ctx, repeatsCollapsing: true, repeatRatePerWindow: existing.windowCount });
-            return;
-        }
-        sink[level](event, ctx);
-    }
-    return {
-        debug: (event, ctx) => { emit("debug", event, ctx); },
-        info: (event, ctx) => { emit("info", event, ctx); },
-        warn: (event, ctx) => { emit("warn", event, ctx); },
-        error: (event, ctx) => { emit("error", event, ctx); },
-    };
-}
-//# sourceMappingURL=log-collapse.js.map

package/dist/log-collapse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"log-collapse.js","sourceRoot":"","sources":["../src/log-collapse.ts"],"names":[],"mappings":"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"}