@newrelic/preflight 1.68.0 → 1.70.0

package/dist/data/dashboards/ai-coding-assistant-adoption-cost.json

@@ -1,6 +1,6 @@
 {
   "name": "AI Coding Assistant — Adoption & Cost",
-  "description": "Org-wide adoption, spend, tool/MCP usage, and team leaderboard built entirely from Preflight events. Works on every supported platform with no additional telemetry.",
+  "description": "Org-wide adoption, spend, tool, skill, and MCP usage, and team leaderboard built entirely from Preflight events. Works on every supported platform with no additional telemetry.",
   "permissions": "PUBLIC_READ_WRITE",
   "pages": [
     {
@@ -930,6 +930,296 @@
         }
       ]
     },
+    {
+      "name": "Skills",
+      "description": null,
+      "widgets": [
+        {
+          "title": "Reading Skill Data",
+          "layout": {
+            "column": 1,
+            "row": 1,
+            "width": 12,
+            "height": 1
+          },
+          "visualization": {
+            "id": "viz.markdown"
+          },
+          "rawConfiguration": {
+            "text": "A skill run opens on a named `Skill` call or a `/<skill>` prompt and lasts until the next prompt or the next skill. Every tool call inside the run carries `skill_name`, `skill_source` (`tool` or `slash`), and `skill_run_id`, so runs, time, and cost here cover all the work a skill drove, not only the call that loaded it. Cost comes from `AiTurnCost`, which splits each turn evenly across its tool calls; a run whose replies made no tool calls has no rows. These widgets need a Preflight release with #895. Earlier events carry only `skillName` on the Skill call itself."
+          }
+        },
+        {
+          "title": "Spend in Skills (7d)",
+          "layout": {
+            "column": 1,
+            "row": 2,
+            "width": 3,
+            "height": 3
+          },
+          "visualization": {
+            "id": "viz.billboard"
+          },
+          "rawConfiguration": {
+            "facet": {
+              "showOtherSeries": false
+            },
+            "nrqlQueries": [
+              {
+                "accountIds": [],
+                "query": "FROM AiTurnCost SELECT filter(sum(cost_usd), WHERE skill_name IS NOT NULL) / sum(cost_usd) * 100 AS 'Spend in Skills %' SINCE 7 days ago"
+              }
+            ],
+            "platformOptions": {
+              "ignoreTimeRange": false
+            }
+          }
+        },
+        {
+          "title": "Skill Runs (7d)",
+          "layout": {
+            "column": 4,
+            "row": 2,
+            "width": 3,
+            "height": 3
+          },
+          "visualization": {
+            "id": "viz.billboard"
+          },
+          "rawConfiguration": {
+            "facet": {
+              "showOtherSeries": false
+            },
+            "nrqlQueries": [
+              {
+                "accountIds": [],
+                "query": "FROM AiToolCall SELECT uniqueCount(skill_run_id) AS 'Runs' WHERE skill_name IS NOT NULL SINCE 7 days ago"
+              }
+            ],
+            "platformOptions": {
+              "ignoreTimeRange": false
+            }
+          }
+        },
+        {
+          "title": "Skill Users (7d)",
+          "layout": {
+            "column": 7,
+            "row": 2,
+            "width": 3,
+            "height": 3
+          },
+          "visualization": {
+            "id": "viz.billboard"
+          },
+          "rawConfiguration": {
+            "facet": {
+              "showOtherSeries": false
+            },
+            "nrqlQueries": [
+              {
+                "accountIds": [],
+                "query": "FROM AiToolCall SELECT uniqueCount(developer) AS 'Users' WHERE skill_name IS NOT NULL SINCE 7 days ago"
+              }
+            ],
+            "platformOptions": {
+              "ignoreTimeRange": false
+            }
+          }
+        },
+        {
+          "title": "How Skills Are Invoked (7d)",
+          "layout": {
+            "column": 10,
+            "row": 2,
+            "width": 3,
+            "height": 3
+          },
+          "visualization": {
+            "id": "viz.pie"
+          },
+          "rawConfiguration": {
+            "facet": {
+              "showOtherSeries": false
+            },
+            "legend": {
+              "enabled": true
+            },
+            "nrqlQueries": [
+              {
+                "accountIds": [],
+                "query": "FROM AiToolCall SELECT uniqueCount(skill_run_id) AS 'Runs' WHERE skill_name IS NOT NULL FACET skill_source SINCE 7 days ago"
+              }
+            ],
+            "platformOptions": {
+              "ignoreTimeRange": false
+            }
+          }
+        },
+        {
+          "title": "Top Skills by Runs (7d)",
+          "layout": {
+            "column": 1,
+            "row": 5,
+            "width": 6,
+            "height": 3
+          },
+          "visualization": {
+            "id": "viz.bar"
+          },
+          "rawConfiguration": {
+            "facet": {
+              "showOtherSeries": false
+            },
+            "nrqlQueries": [
+              {
+                "accountIds": [],
+                "query": "FROM AiToolCall SELECT uniqueCount(skill_run_id) AS 'Runs' WHERE skill_name IS NOT NULL FACET skill_name SINCE 7 days ago LIMIT 25"
+              }
+            ],
+            "platformOptions": {
+              "ignoreTimeRange": false
+            }
+          }
+        },
+        {
+          "title": "Daily Skill Runs (7d)",
+          "layout": {
+            "column": 7,
+            "row": 5,
+            "width": 6,
+            "height": 3
+          },
+          "visualization": {
+            "id": "viz.line"
+          },
+          "rawConfiguration": {
+            "facet": {
+              "showOtherSeries": false
+            },
+            "legend": {
+              "enabled": true
+            },
+            "yAxisLeft": {
+              "zero": true
+            },
+            "nrqlQueries": [
+              {
+                "accountIds": [],
+                "query": "FROM AiToolCall SELECT uniqueCount(skill_run_id) AS 'Runs' WHERE skill_name IS NOT NULL FACET skill_name SINCE 7 days ago TIMESERIES 1 day LIMIT 10"
+              }
+            ],
+            "platformOptions": {
+              "ignoreTimeRange": false
+            }
+          }
+        },
+        {
+          "title": "Skill Cost (7d)",
+          "layout": {
+            "column": 1,
+            "row": 8,
+            "width": 6,
+            "height": 4
+          },
+          "visualization": {
+            "id": "viz.table"
+          },
+          "rawConfiguration": {
+            "facet": {
+              "showOtherSeries": false
+            },
+            "nrqlQueries": [
+              {
+                "accountIds": [],
+                "query": "FROM AiToolCall, AiTurnCost SELECT uniqueCount(skill_run_id) AS 'Runs', sum(cost_usd) AS 'Cost (USD)', sum(cost_usd) / uniqueCount(skill_run_id) AS 'USD / Run', sum(input_tokens + output_tokens + cache_read_tokens + cache_creation_tokens) AS 'Tokens' WHERE skill_name IS NOT NULL FACET skill_name SINCE 7 days ago LIMIT 25"
+              }
+            ],
+            "platformOptions": {
+              "ignoreTimeRange": false
+            }
+          }
+        },
+        {
+          "title": "Skill Adoption (7d)",
+          "layout": {
+            "column": 7,
+            "row": 8,
+            "width": 6,
+            "height": 4
+          },
+          "visualization": {
+            "id": "viz.table"
+          },
+          "rawConfiguration": {
+            "facet": {
+              "showOtherSeries": false
+            },
+            "nrqlQueries": [
+              {
+                "accountIds": [],
+                "query": "FROM AiToolCall SELECT uniqueCount(developer) AS 'Users', uniqueCount(skill_run_id) AS 'Runs', count(*) AS 'Tool Calls', filter(sum(duration_ms), WHERE tool != 'Agent') / 3600000 AS 'Hours', percentage(count(*), WHERE success = false) AS 'Error %' WHERE skill_name IS NOT NULL FACET skill_name SINCE 7 days ago LIMIT 25"
+              }
+            ],
+            "platformOptions": {
+              "ignoreTimeRange": false
+            }
+          }
+        },
+        {
+          "title": "Skills by Developer (7d)",
+          "layout": {
+            "column": 1,
+            "row": 12,
+            "width": 6,
+            "height": 4
+          },
+          "visualization": {
+            "id": "viz.table"
+          },
+          "rawConfiguration": {
+            "facet": {
+              "showOtherSeries": false
+            },
+            "nrqlQueries": [
+              {
+                "accountIds": [],
+                "query": "FROM AiToolCall SELECT uniqueCount(skill_run_id) AS 'Runs', filter(sum(duration_ms), WHERE tool != 'Agent') / 3600000 AS 'Hours' WHERE skill_name IS NOT NULL FACET developer, skill_name SINCE 7 days ago LIMIT 100"
+              }
+            ],
+            "platformOptions": {
+              "ignoreTimeRange": false
+            }
+          }
+        },
+        {
+          "title": "Tools Driven by Skills (7d)",
+          "layout": {
+            "column": 7,
+            "row": 12,
+            "width": 6,
+            "height": 4
+          },
+          "visualization": {
+            "id": "viz.table"
+          },
+          "rawConfiguration": {
+            "facet": {
+              "showOtherSeries": false
+            },
+            "nrqlQueries": [
+              {
+                "accountIds": [],
+                "query": "FROM AiToolCall SELECT count(*) AS 'Calls', percentage(count(*), WHERE success = false) AS 'Error %' WHERE skill_name IS NOT NULL AND tool != 'Skill' FACET skill_name, tool SINCE 7 days ago LIMIT 50"
+              }
+            ],
+            "platformOptions": {
+              "ignoreTimeRange": false
+            }
+          }
+        }
+      ]
+    },
     {
       "name": "Team Leaderboard",
       "description": null,

package/dist/data/dashboards/ai-coding-assistant-team-view.json

@@ -1,10 +1,10 @@
 {
-  "name": "AI Coding Assistant \u2014 Team View",
+  "name": "AI Coding Assistant — Team View",
   "description": "Team-level dashboard for AI coding assistant observability. Shows cost rollups, efficiency scores by developer, trend lines, and optimization insights across sessions. Requires AiToolCall, AiCodingTask, AiAntiPattern custom events and ai.* metrics.",
   "permissions": "PUBLIC_READ_WRITE",
   "pages": [
     {
-      "name": "AI Coding Assistant \u2014 Team View",
+      "name": "AI Coding Assistant — Team View",
       "description": "Team summary, developer comparison, trends, and optimization insights",
       "widgets": [
         {
@@ -308,7 +308,7 @@
           }
         },
         {
-          "title": "Skill Calls (7d)",
+          "title": "Skill Runs (7d)",
           "layout": {
             "column": 1,
             "row": 13,
@@ -322,7 +322,7 @@
             "nrqlQueries": [
               {
                 "accountIds": [],
-                "query": "SELECT count(*) FROM AiToolCall WHERE tool = 'Skill' AND developer = {{developer}} AND session_id = {{session_id}} FACET skillName SINCE 7 DAYS AGO LIMIT 20"
+                "query": "SELECT uniqueCount(skill_run_id) AS 'Runs' FROM AiToolCall WHERE skill_name IS NOT NULL AND developer = {{developer}} AND session_id = {{session_id}} FACET skill_name SINCE 7 DAYS AGO LIMIT 20"
               }
             ]
           }
@@ -342,7 +342,7 @@
             "nrqlQueries": [
               {
                 "accountIds": [],
-                "query": "SELECT sum(duration_ms) / 3600000 AS 'Hours' FROM AiToolCall WHERE tool = 'Skill' AND developer = {{developer}} AND session_id = {{session_id}} FACET skillName SINCE 7 DAYS AGO LIMIT 20"
+                "query": "SELECT filter(sum(duration_ms), WHERE tool != 'Agent') / 3600000 AS 'Hours' FROM AiToolCall WHERE skill_name IS NOT NULL AND developer = {{developer}} AND session_id = {{session_id}} FACET skill_name SINCE 7 DAYS AGO LIMIT 20"
               }
             ]
           }
@@ -362,7 +362,7 @@
             "nrqlQueries": [
               {
                 "accountIds": [],
-                "query": "SELECT sum(cost_usd) AS 'USD' FROM AiTurnCost WHERE tool = 'Skill' AND developer = {{developer}} AND session_id = {{session_id}} FACET skillName SINCE 7 DAYS AGO LIMIT 20"
+                "query": "SELECT sum(cost_usd) AS 'USD' FROM AiTurnCost WHERE skill_name IS NOT NULL AND developer = {{developer}} AND session_id = {{session_id}} FACET skill_name SINCE 7 DAYS AGO LIMIT 20"
               }
             ]
           }

package/dist/hooks/billed-turn-ledger.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Append order in an O_APPEND file is the cross-process arbiter, so two
+ * racing claimants both read back the same winner without a lock. A message
+ * id maps to one file per generation, chosen by a hash of the id and the
+ * claim's wall clock rather than the turn's timestamp, so every line of a
+ * message is arbitrated in the same file. Each ledger instance claims under
+ * its own random claimant id, so two processes tailing the same session
+ * still resolve to one winner.
+ */
+export interface BillableTurn {
+    readonly messageId: string;
+    readonly timestampMs: number;
+    /** The source line had no timestamp, so the retention horizon cannot judge the turn. */
+    readonly undated?: boolean;
+}
+export interface BilledTurnLedgerOptions {
+    readonly storagePath: string;
+    readonly retainDays?: number | null;
+    readonly now?: () => number;
+}
+export declare class BilledTurnLedger {
+    private readonly dir;
+    private readonly retainDays;
+    private readonly now;
+    private readonly claimant;
+    private readonly files;
+    private readonly undelivered;
+    constructor(options: BilledTurnLedgerOptions);
+    /**
+     * Appends, in order, the turns this session owes: the first line of each
+     * message this instance claimed first and has not delivered yet. A turn
+     * claimed first by any other instance, of any session, is already billed.
+     * When `append` throws, that turn and the rest stay owed to this session,
+     * so the next deliver() redoing the read appends them, and the error is
+     * rethrown.
+     */
+    deliver<T extends BillableTurn>(sessionId: string, turns: readonly T[], append: (turn: T) => void): void;
+    private claim;
+    private claimantOf;
+    /** Generations on disk per shard. Drops the index of any file no longer listed. */
+    private listGenerations;
+    private syncFiles;
+    private syncFile;
+}
+export declare function pruneBilledTurns(storagePath: string, retainDays: number, nowMs: number): number;
+//# sourceMappingURL=billed-turn-ledger.d.ts.map

package/dist/hooks/billed-turn-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"billed-turn-ledger.d.ts","sourceRoot":"","sources":["../../src/hooks/billed-turn-ledger.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAmBH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wFAAwF;IACxF,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AAoBD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;IAKtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;gBAE7C,OAAO,EAAE,uBAAuB;IAM5C;;;;;;;OAOG;IACH,OAAO,CAAC,CAAC,SAAS,YAAY,EAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,GACxB,IAAI;IAOP,OAAO,CAAC,KAAK;IAqEb,OAAO,CAAC,UAAU;IAQlB,mFAAmF;IACnF,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,SAAS;IAkBjB,OAAO,CAAC,QAAQ;CAmBjB;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAiB/F"}

package/dist/hooks/billed-turn-ledger.js

@@ -0,0 +1,274 @@
+/**
+ * Append order in an O_APPEND file is the cross-process arbiter, so two
+ * racing claimants both read back the same winner without a lock. A message
+ * id maps to one file per generation, chosen by a hash of the id and the
+ * claim's wall clock rather than the turn's timestamp, so every line of a
+ * message is arbitrated in the same file. Each ledger instance claims under
+ * its own random claimant id, so two processes tailing the same session
+ * still resolve to one winner.
+ */
+import { createHash, randomUUID } from 'node:crypto';
+import { appendFileSync, closeSync, fstatSync, mkdirSync, openSync, readdirSync, readSync, unlinkSync, } from 'node:fs';
+import { join } from 'node:path';
+import { createLogger } from '../shared/index.js';
+const logger = createLogger('billed-turn-ledger');
+const LEDGER_DIR = 'billed-turns';
+const DAY_MS = 24 * 60 * 60 * 1000;
+const GENERATION_MS = 7 * DAY_MS;
+const LEDGER_FILE = /^g(\d+)-([0-9a-f])\.jsonl$/;
+const TORN_LINE_TERMINATOR = '\n';
+const HEAD_BYTES = 256;
+const NEWLINE = 0x0a;
+export class BilledTurnLedger {
+    dir;
+    retainDays;
+    now;
+    claimant = randomUUID();
+    files = new Map();
+    // The session each message this instance won is still owed to: a claim
+    // that threw after some of its lines landed, a turn whose append threw, or
+    // one whose claim line vanished before it was read back. Only this map lets
+    // the ledger's own claims out, and only to the session they were won for.
+    undelivered = new Map();
+    constructor(options) {
+        this.dir = join(options.storagePath, LEDGER_DIR);
+        this.retainDays = options.retainDays ?? null;
+        this.now = options.now ?? Date.now;
+    }
+    /**
+     * Appends, in order, the turns this session owes: the first line of each
+     * message this instance claimed first and has not delivered yet. A turn
+     * claimed first by any other instance, of any session, is already billed.
+     * When `append` throws, that turn and the rest stay owed to this session,
+     * so the next deliver() redoing the read appends them, and the error is
+     * rethrown.
+     */
+    deliver(sessionId, turns, append) {
+        for (const turn of this.claim(sessionId, turns)) {
+            append(turn);
+            this.undelivered.delete(turn.messageId);
+        }
+    }
+    claim(sessionId, turns) {
+        const nowMs = this.now();
+        const horizon = horizonOf(nowMs, this.retainDays);
+        const firstLines = new Map();
+        let refused = 0;
+        for (const turn of turns) {
+            if (firstLines.has(turn.messageId))
+                continue;
+            const beyond = !turn.undated && Number.isFinite(turn.timestampMs) && turn.timestampMs < horizon;
+            if (beyond)
+                refused++;
+            firstLines.set(turn.messageId, beyond ? null : turn);
+        }
+        if (refused > 0) {
+            logger.debug('Refused turns older than the retention horizon', {
+                refused,
+                retainDays: this.retainDays,
+            });
+        }
+        const live = [...firstLines.values()].filter((turn) => turn !== null);
+        if (live.length === 0)
+            return [];
+        // Two processes either side of a generation boundary can both win a
+        // brand-new message claimed within the same few milliseconds.
+        const home = Math.floor(nowMs / GENERATION_MS);
+        const generations = this.listGenerations();
+        const filesOf = (messageId) => {
+            const shard = shardOf(messageId);
+            const gens = new Set([...(generations.get(shard) ?? []), home]);
+            return [...gens].sort((a, b) => a - b).map((gen) => fileName(gen, shard));
+        };
+        this.syncFiles(live.flatMap((turn) => filesOf(turn.messageId)));
+        const owed = [];
+        const linesByFile = new Map();
+        for (const turn of live) {
+            const id = turn.messageId;
+            const claimant = this.claimantOf(id, filesOf(id));
+            if (claimant === undefined) {
+                const file = fileName(home, shardOf(id));
+                const line = TORN_LINE_TERMINATOR +
+                    JSON.stringify({ m: id, s: sessionId, c: this.claimant, t: nowMs });
+                linesByFile.set(file, (linesByFile.get(file) ?? '') + line);
+                this.undelivered.set(id, sessionId);
+            }
+            else if (claimant !== this.claimant) {
+                this.undelivered.delete(id);
+                continue;
+            }
+            else if (this.undelivered.get(id) !== sessionId) {
+                continue;
+            }
+            owed.push(turn);
+        }
+        if (owed.length === 0)
+            return [];
+        if (linesByFile.size > 0)
+            mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+        for (const [file, lines] of linesByFile) {
+            appendFileSync(join(this.dir, file), lines + '\n', { mode: 0o600 });
+        }
+        this.syncFiles(owed.flatMap((turn) => filesOf(turn.messageId)));
+        return owed.filter((turn) => {
+            const claimant = this.claimantOf(turn.messageId, filesOf(turn.messageId));
+            if (claimant !== undefined && claimant !== this.claimant) {
+                this.undelivered.delete(turn.messageId);
+            }
+            return claimant === this.claimant;
+        });
+    }
+    claimantOf(messageId, files) {
+        for (const file of files) {
+            const claimant = this.files.get(file)?.claimants.get(messageId);
+            if (claimant !== undefined)
+                return claimant;
+        }
+        return undefined;
+    }
+    /** Generations on disk per shard. Drops the index of any file no longer listed. */
+    listGenerations() {
+        const listed = new Set();
+        const generations = new Map();
+        for (const name of readLedgerDir(this.dir)) {
+            const parsed = parseFileName(name);
+            if (parsed === null)
+                continue;
+            listed.add(name);
+            generations.set(parsed.shard, [...(generations.get(parsed.shard) ?? []), parsed.generation]);
+        }
+        for (const name of this.files.keys()) {
+            if (!listed.has(name))
+                this.files.delete(name);
+        }
+        return generations;
+    }
+    syncFiles(files) {
+        for (const file of new Set(files)) {
+            let fd;
+            try {
+                fd = openSync(join(this.dir, file), 'r');
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT')
+                    throw err;
+                this.files.delete(file);
+                continue;
+            }
+            try {
+                this.syncFile(file, fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+        }
+    }
+    syncFile(file, fd) {
+        const { size } = fstatSync(fd);
+        const head = readAt(fd, 0, Math.min(size, HEAD_BYTES));
+        let index = this.files.get(file);
+        if (index === undefined || size < index.offset || !onePrefixesOther(head, index.head)) {
+            index = { head, offset: 0, partial: Buffer.alloc(0), claimants: new Map() };
+            this.files.set(file, index);
+        }
+        else if (head.length > index.head.length) {
+            index.head = head;
+        }
+        if (size <= index.offset)
+            return;
+        const tail = readAt(fd, index.offset, size);
+        const bytes = Buffer.concat([index.partial, tail]);
+        const end = bytes.lastIndexOf(NEWLINE) + 1;
+        foldLines(bytes.subarray(0, end), index.claimants, file);
+        index.partial = Buffer.from(bytes.subarray(end));
+        index.offset += tail.length;
+    }
+}
+export function pruneBilledTurns(storagePath, retainDays, nowMs) {
+    const dir = join(storagePath, LEDGER_DIR);
+    const horizon = horizonOf(nowMs, retainDays);
+    let deleted = 0;
+    for (const name of readLedgerDir(dir)) {
+        const parsed = parseFileName(name);
+        if (parsed === null || (parsed.generation + 1) * GENERATION_MS > horizon)
+            continue;
+        try {
+            unlinkSync(join(dir, name));
+            deleted++;
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                logger.warn('Failed to prune billed-turn ledger file', { file: name, error: String(err) });
+            }
+        }
+    }
+    return deleted;
+}
+/**
+ * Turns dated before the horizon are refused and generations ending by it
+ * are pruned. A turn is claimed no earlier than its own timestamp, so a
+ * pruned generation only ever held claims for turns the horizon refuses.
+ */
+function horizonOf(nowMs, retainDays) {
+    if (retainDays === null || !(retainDays > 0))
+        return -Infinity;
+    return nowMs - retainDays * DAY_MS;
+}
+function shardOf(messageId) {
+    return createHash('sha256').update(messageId).digest('hex')[0];
+}
+function fileName(generation, shard) {
+    return `g${generation}-${shard}.jsonl`;
+}
+function parseFileName(name) {
+    const match = LEDGER_FILE.exec(name);
+    return match ? { generation: Number(match[1]), shard: match[2] } : null;
+}
+function readLedgerDir(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+}
+function onePrefixesOther(a, b) {
+    const n = Math.min(a.length, b.length);
+    return a.subarray(0, n).equals(b.subarray(0, n));
+}
+function readAt(fd, start, end) {
+    const buf = Buffer.allocUnsafe(Math.max(0, end - start));
+    let read = 0;
+    while (read < buf.length) {
+        const n = readSync(fd, buf, read, buf.length - read, start + read);
+        if (n === 0)
+            break;
+        read += n;
+    }
+    return buf.subarray(0, read);
+}
+function foldLines(bytes, claimants, file) {
+    let start = 0;
+    while (start < bytes.length) {
+        const end = bytes.indexOf(NEWLINE, start);
+        const line = bytes.subarray(start, end);
+        start = end + 1;
+        if (line.length === 0)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line.toString('utf-8'));
+        }
+        catch {
+            logger.debug('Skipped a torn billed-turn ledger line', { file, bytes: line.length });
+            continue;
+        }
+        if (typeof parsed.m !== 'string')
+            continue;
+        if (!claimants.has(parsed.m))
+            claimants.set(parsed.m, typeof parsed.c === 'string' ? parsed.c : '');
+    }
+}
+//# sourceMappingURL=billed-turn-ledger.js.map