@smthrs/gateway 0.35.0 → 1.0.0-rc.4

package/dist/esm/Diagnosis.js

@@ -0,0 +1,697 @@
+/**
+ * The run diagnosis: what happened to a run, computed from its own control
+ * events.
+ *
+ * The old gateway answered this question with a `whatHappened` RPC that read
+ * run rows, node-iteration rows, and attempt rows out of the engine database
+ * and optionally asked an agent to narrate them. The rc.0 gateway serves the
+ * same answer as a field of the `run-summary` projection, computed from the
+ * ordered `ControlEvent` deltas `Control.watch` already publishes. Nothing
+ * here opens a database, so a diagnosis read through a relay is the same
+ * diagnosis a local reader computes.
+ *
+ * This is the one fold both surfaces read. `@smthrs/cli` `Forensics` calls
+ * `digest` and adds what a terminal card needs on top of it: duplicate calls,
+ * per-flow counts, the parked approval payload, and the declined-launch state
+ * the wire vocabulary does not carry. The counts, the refusal aggregation, and
+ * the clipping are therefore one implementation, not two that drift.
+ *
+ * @since 1.0.0
+ */
+import { ControlSchema } from "@smthrs/control";
+import * as Fault from "@smthrs/flow/Fault";
+import { HashMap, Schema } from "effect";
+import { callEventKey, callScope, nativeCallEvent, nativeStepEvent, uniqueCallEvents } from "./internal/callEvents.js";
+import * as DigestIndex from "./internal/digestIndex.js";
+import { encodedBytes, recordDigestBytes } from "./internal/digestMemory.js";
+import * as NativeResolution from "./internal/nativeResolution.js";
+/**
+ * Keeps one start and settlement per durable call identity, preferring a
+ * committed native fact over telemetry at the first observation's position.
+ * Unidentified legacy events remain distinct because their identity cannot
+ * be recovered from flow names and inputs. Shared with CLI call counts.
+ *
+ * @since 1.0.0
+ * @category projections
+ */
+export { uniqueCallEvents };
+/**
+ * Native fact normalization and stable call/checkpoint identities.
+ * Incremental readers retain these keys to match the full history fold.
+ *
+ * @since 1.0.0
+ * @category projections
+ */
+export { callEventKey, callScope, nativeCallEvent, nativeStepEvent } from "./internal/callEvents.js";
+/**
+ * Finds an open call by ID, with name/FIFO fallback only for legacy starts.
+ * Shared by gateway node output and the CLI's compatible flow/ordinal IDs.
+ *
+ * @since 1.0.0
+ * @category projections
+ */
+export { openCallIndex } from "./internal/callEvents.js";
+/**
+ * Every `control.run.*` suffix that names a status rather than an operation.
+ *
+ * `@smthrs/control` journals `control.run.lineage`, `control.run.resume`,
+ * `control.run.resumed`, `control.run.cancel-requested`, and
+ * `control.run.pending` under the same prefix as the status transitions, and
+ * `Lineage.derive` adds one more to every followed stream. Reading a status
+ * off the prefix alone made a live run's verdict read `lineage` or `resume`,
+ * so the fold accepts only the schema statuses a client may render.
+ */
+const runStatuses = new Set(ControlSchema.RunStatus.literals);
+/** Flows whose calls count as edit attempts. */
+const editFlows = new Set(["write", "edit", "apply_patch"]);
+/**
+ * Reads a payload as a record. Wire payloads are `Json`, so every field read
+ * tolerates absence and the digest of a malformed journal is a sparse digest,
+ * never a throw.
+ *
+ * @param value the payload to read
+ * @since 1.0.0
+ * @category conversions
+ */
+export const asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+/**
+ * Reads a payload field as a string, or nothing when it is not one.
+ *
+ * @param value the field to read
+ * @since 1.0.0
+ * @category conversions
+ */
+export const asString = (value) => typeof value === "string" ? value : undefined;
+const isFault = Schema.is(Fault.Fault);
+/**
+ * Reads a payload field as a number, or nothing when it is not one.
+ *
+ * @param value the field to read
+ * @since 1.0.0
+ * @category conversions
+ */
+export const asNumber = (value) => typeof value === "number" ? value : undefined;
+/**
+ * Occurrence time: the payload's own stamp, else journal admission time.
+ *
+ * @param event the event to time
+ * @since 1.0.0
+ * @category conversions
+ */
+export const timeOf = (event) => asNumber(asRecord(event.payload).at) ?? event.occurredAt;
+/**
+ * The first line, whichever line ending produced it. Splitting on `\n` alone
+ * left the `\r` of a CRLF cause on the wire, and every reader of a one-line
+ * field, here and in `@smthrs/cli` `Forensics`, wants the same answer.
+ *
+ * @param text the text to read one line of
+ * @since 1.0.0
+ * @category conversions
+ */
+export const firstLine = (text) => {
+    const index = text.search(/[\r\n]/);
+    return index < 0 ? text : text.slice(0, index);
+};
+/**
+ * Truncates to a display width, marking the cut.
+ *
+ * The cut is made on code points, never on UTF-16 code units. Slicing code
+ * units splits an astral character in half and puts a lone surrogate on the
+ * wire, where a Go decoder silently replaces it with U+FFFD and a strict
+ * decoder rejects the whole frame; the result of this function is always well
+ * formed. A clipped result is exactly `width` code points, so `width` 1 is the
+ * ellipsis alone and `width` 0, or any negative width, is the empty string.
+ *
+ * @param text the text to clip
+ * @param width the greatest number of code points to keep
+ * @since 1.0.0
+ * @category rendering
+ */
+export const clip = (text, width) => {
+    if (width <= 0)
+        return "";
+    const points = [...text];
+    return points.length <= width ? text : `${points.slice(0, width - 1).join("")}…`;
+};
+const handlers = {
+    "control.agent.turn-opened": {
+        reach: "aggregate",
+        apply: (accumulator, payload) => {
+            accumulator.turns += 1;
+            accumulator.seat = asString(payload.seat) ?? accumulator.seat;
+        }
+    },
+    "control.agent.model-settled": {
+        reach: "aggregate",
+        apply: (accumulator, payload) => {
+            const usage = asRecord(payload.usage);
+            accumulator.inputTokens += asNumber(usage.inputTokens) ?? 0;
+            accumulator.outputTokens += asNumber(usage.outputTokens) ?? 0;
+            const cost = asNumber(payload.costUsd);
+            if (cost !== undefined && Number.isFinite(cost) && cost > 0)
+                accumulator.costUsd += cost;
+        }
+    },
+    "control.agent.cell-call-started": {
+        reach: "aggregate",
+        apply: (accumulator, payload) => {
+            accumulator.calls += 1;
+            if (editFlows.has(asString(payload.flowName) ?? ""))
+                accumulator.editsAttempted += 1;
+        }
+    },
+    "control.agent.resolved": {
+        reach: "root",
+        apply: (accumulator, payload) => {
+            accumulator.finalOutput = asString(payload.text);
+        }
+    },
+    "control.approval.requested": {
+        reach: "root",
+        apply: (accumulator, payload) => {
+            accumulator.parkedQuestion = asString(payload.question);
+        }
+    }
+};
+/**
+ * The kinds this fold handles, with the class each one's fields belong to.
+ *
+ * Exported so a test can hold the table above against the map rather than
+ * trusting a comment, and so a new handler that names no class fails both the
+ * compiler and that test.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export const handlerReach = Object.fromEntries(Object.entries(handlers).map(([kind, handler]) => [kind, handler.reach]));
+/**
+ * Computes the diagnosis facts for one run from its ordered control events.
+ *
+ * Total on purpose: an event this vocabulary does not know contributes
+ * nothing rather than failing the fold.
+ *
+ * @param events the run's ordered control events
+ * @since 1.0.0
+ * @category constructors
+ */
+const rawDigest = (events) => {
+    const accumulator = {
+        status: undefined,
+        cause: undefined,
+        fault: undefined,
+        seat: undefined,
+        turns: 0,
+        calls: 0,
+        callsFailed: 0,
+        editsAttempted: 0,
+        editsSucceeded: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        costUsd: 0,
+        finalOutput: undefined,
+        parkedQuestion: undefined
+    };
+    const refusalCounts = new Map();
+    let startedAt;
+    let endedAt;
+    let nativeResolution;
+    /**
+     * Widens the span this digest reports.
+     *
+     * Only a kind this fold handles widens it. The gateway merges a keepalive
+     * event whose kind no emitter uses into every followed `Watch` stream
+     * (`GatewayServer.watchHeartbeatKind`), and a fold that let an unhandled kind
+     * contribute its timestamp reported a run that ran for as long as it was
+     * watched.
+     */
+    const observe = (at) => {
+        startedAt = startedAt === undefined ? at : Math.min(startedAt, at);
+        endedAt = endedAt === undefined ? at : Math.max(endedAt, at);
+    };
+    for (const event of uniqueCallEvents(events)) {
+        nativeResolution = NativeResolution.combine(nativeResolution, NativeResolution.fromEvent(event));
+        const payload = asRecord(event.payload);
+        const at = timeOf(event);
+        const handler = Object.hasOwn(handlers, event.kind) ? handlers[event.kind] : undefined;
+        if (handler !== undefined) {
+            // A step's record still widens the span it was recorded in, because the
+            // step ran inside this run. Whether it may write the field is the
+            // handler's class: a root-only field keeps the root's reading.
+            observe(at);
+            if (handler.reach === "aggregate" || callScope(event) === undefined)
+                handler.apply(accumulator, payload);
+            continue;
+        }
+        if (event.kind === "control.agent.cell-call-settled") {
+            observe(at);
+            if (asString(payload.outcome) === "failure") {
+                accumulator.callsFailed += 1;
+                const message = firstLine(asString(payload.message) ?? "unknown refusal");
+                refusalCounts.set(message, (refusalCounts.get(message) ?? 0) + 1);
+            }
+            else if (editFlows.has(asString(payload.flowName) ?? "")) {
+                accumulator.editsSucceeded += 1;
+            }
+            continue;
+        }
+        if (event.kind.startsWith("control.run.")) {
+            const status = event.kind.slice("control.run.".length);
+            if (!runStatuses.has(status))
+                continue;
+            observe(at);
+            accumulator.status = status;
+            if (status === "failed")
+                accumulator.cause = asString(payload.cause);
+            // A resumed run is no longer failed, so the fault of its last failure goes.
+            accumulator.fault = status === "failed" && isFault(payload.fault) ? payload.fault : undefined;
+        }
+    }
+    return {
+        ...accumulator,
+        ...(nativeResolution === undefined ? {} : { nativeResolution }),
+        refusals: [...refusalCounts.entries()]
+            .map(([message, count]) => ({ message, count }))
+            .sort((left, right) => right.count - left.count),
+        startedAt,
+        endedAt
+    };
+};
+const counters = [
+    "turns",
+    "calls",
+    "callsFailed",
+    "editsAttempted",
+    "editsSucceeded",
+    "inputTokens",
+    "outputTokens",
+    "costUsd"
+];
+const contributionValue = (value) => ({
+    ...Object.fromEntries(counters.filter((counter) => value[counter] !== 0).map((counter) => [counter, value[counter]])),
+    ...(value.seat === undefined ? {} : { seat: value.seat }),
+    ...(value.startedAt === undefined ? {} : { startedAt: value.startedAt }),
+    ...(value.endedAt === undefined ? {} : { endedAt: value.endedAt }),
+    ...(value.refusals.length === 0 ? {} : { refusals: value.refusals })
+});
+const emptyIndexes = () => ({ timings: undefined, refusals: HashMap.empty(), refusalBytes: 0 });
+const refusalIndexBytes = (message, tree) => tree === undefined ? 0 : encodedBytes(message) + tree.bytes;
+const indexContribution = (indexes, previous, next) => {
+    let refusals = indexes.refusals;
+    let refusalBytes = indexes.refusalBytes;
+    for (const refusal of previous?.value.refusals ?? []) {
+        if (next.value.refusals?.some((member) => member.message === refusal.message))
+            continue;
+        // Every previous refusal was indexed when its contribution was retained.
+        const oldTree = HashMap.getUnsafe(refusals, refusal.message);
+        const tree = DigestIndex.remove(oldTree, next.ordinal);
+        refusalBytes += refusalIndexBytes(refusal.message, tree) - refusalIndexBytes(refusal.message, oldTree);
+        refusals = tree === undefined
+            ? HashMap.remove(refusals, refusal.message)
+            : HashMap.set(refusals, refusal.message, tree);
+    }
+    for (const refusal of next.value.refusals ?? []) {
+        if (previous?.value.refusals?.some((member) => member.message === refusal.message))
+            continue;
+        const old = HashMap.get(refusals, refusal.message);
+        const oldTree = old._tag === "Some" ? old.value : undefined;
+        const tree = DigestIndex.set(oldTree, next.ordinal);
+        refusalBytes += refusalIndexBytes(refusal.message, tree) - refusalIndexBytes(refusal.message, oldTree);
+        refusals = HashMap.set(refusals, refusal.message, tree);
+    }
+    return {
+        timings: DigestIndex.set(indexes.timings, next.ordinal, next.value.startedAt, next.value.endedAt),
+        refusals,
+        refusalBytes
+    };
+};
+// Scalar contributions only: no model input, call output, or event body is
+// retained. Weak associations keep the public Digest and its wire shape intact.
+const digestStates = new WeakMap();
+const remember = (value, state) => {
+    digestStates.set(value, state);
+    recordDigestBytes(value, encodedBytes(value) + (value === state.base ? 0 : encodedBytes(state.base)) +
+        state.contributionBytes + (state.indexes.timings?.bytes ?? 0) + state.indexes.refusalBytes + encodedBytes({
+        writes: state.writes,
+        baseSeatOrdinal: state.baseSeatOrdinal,
+        baseRefusals: [...state.baseRefusals],
+        length: state.length
+    }));
+    return value;
+};
+/**
+ * A `control.run.*` verdict stamped with a run id other than `runId`, such as
+ * a child's riding in the parent's events. It must not set the digested run's
+ * status or failure cause. An unstamped verdict is the run's own.
+ *
+ * @param event the event to classify
+ * @param runId the run being digested; omitted, no verdict is foreign
+ * @category predicates
+ * @since 1.0.0
+ */
+export const foreignVerdict = (event, runId) => runId !== undefined && event.runId !== undefined && event.runId !== runId && event.kind.startsWith("control.run.");
+/**
+ * Folds one event range, retaining compact identities for later combination.
+ * Native facts supersede telemetry at its first position across ranges too.
+ *
+ * @param events the range to fold
+ * @param runId the run being digested; a `control.run.*` verdict stamped with
+ *   another run's id is skipped. Omitted, every verdict folds.
+ * @category constructors
+ * @since 1.0.0
+ */
+export const digest = (events, runId) => {
+    if (runId !== undefined && events.some((event) => foreignVerdict(event, runId))) {
+        events = events.filter((event) => !foreignVerdict(event, runId));
+    }
+    let contributions = HashMap.empty();
+    let indexes = emptyIndexes();
+    let contributionBytes = 0;
+    const baseEvents = [];
+    const baseRefusals = new Map();
+    const writes = { cause: false, finalOutput: false, parkedQuestion: false };
+    let baseSeatOrdinal;
+    for (const [ordinal, event] of events.entries()) {
+        const key = callEventKey(event);
+        if (key === undefined) {
+            baseEvents.push(event);
+            if (event.kind === "control.run.failed")
+                writes.cause = true;
+            if (callScope(event) === undefined) {
+                if (event.kind === "control.agent.resolved")
+                    writes.finalOutput = true;
+                if (event.kind === "control.approval.requested")
+                    writes.parkedQuestion = true;
+            }
+            const payload = asRecord(event.payload);
+            if (event.kind === "control.agent.turn-opened" && asString(payload.seat) !== undefined)
+                baseSeatOrdinal = ordinal;
+            if (event.kind === "control.agent.cell-call-settled" && payload.outcome === "failure") {
+                const message = firstLine(asString(payload.message) ?? "unknown refusal");
+                if (!baseRefusals.has(message))
+                    baseRefusals.set(message, ordinal);
+            }
+            continue;
+        }
+        const native = nativeStepEvent(event) ?? nativeCallEvent(event);
+        const previous = HashMap.get(contributions, key);
+        if (previous._tag === "Some" && (previous.value.authoritative || native === undefined))
+            continue;
+        const contribution = {
+            ordinal: previous._tag === "Some" ? previous.value.ordinal : ordinal,
+            authoritative: native !== undefined,
+            value: contributionValue(rawDigest([native ?? event]))
+        };
+        contributionBytes += encodedBytes([key, contribution]) -
+            (previous._tag === "Some" ? encodedBytes([key, previous.value]) : 0);
+        contributions = HashMap.set(contributions, key, contribution);
+        indexes = indexContribution(indexes, previous._tag === "Some" ? previous.value : undefined, contribution);
+    }
+    const value = rawDigest(events);
+    return remember(value, {
+        base: baseEvents.length === events.length ? value : rawDigest(baseEvents),
+        writes,
+        baseSeatOrdinal,
+        baseRefusals,
+        indexes,
+        contributions,
+        contributionBytes,
+        length: events.length
+    });
+};
+/**
+ * The wall-clock span the events cover, rendered for a reader.
+ *
+ * Only the span is read, so a caller carrying a wider digest of its own, as
+ * `@smthrs/cli` `Forensics` does, measures it with this rather than a copy.
+ *
+ * @param value the span to measure
+ * @since 1.0.0
+ * @category rendering
+ */
+export const duration = (value) => {
+    if (value.startedAt === undefined || value.endedAt === undefined)
+        return "0s";
+    const seconds = Math.max(0, Math.round((value.endedAt - value.startedAt) / 1000));
+    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`;
+};
+/**
+ * A USD amount for a reader: cents from one dollar, four places below it, so
+ * a cheap run never reads as `$0.00`.
+ *
+ * @param value dollars, finite and non-negative
+ * @since 1.0.0
+ * @category rendering
+ */
+export const usd = (value) => `$${value.toFixed(value >= 1 ? 2 : 4)}`;
+/**
+ * Assistant text, or a typed module's committed result under its bound root.
+ * @category projections
+ * @since 1.0.0
+ */
+export const resolvedOutput = (value) => value.finalOutput ?? NativeResolution.output(value.nativeResolution);
+/**
+ * The one-line verdict: the status plus the reason that most explains it.
+ *
+ * Priority order mirrors what a reader needs first: a recorded failure cause,
+ * then a park's question, then the "worked but never edited" pathology a green
+ * status would otherwise hide, then the resolved output.
+ *
+ * @param value the digest to judge
+ * @since 1.0.0
+ * @category rendering
+ */
+export const verdict = (value) => {
+    const status = value.status ?? "unlaunched";
+    const output = resolvedOutput(value);
+    if (status === "failed") {
+        return value.cause === undefined
+            ? "failed — no cause recorded in the journal"
+            : `failed — ${clip(firstLine(value.cause), 100)}`;
+    }
+    if (status === "waiting-approval") {
+        return value.parkedQuestion === undefined
+            ? "waiting-approval — a permission gate is pending"
+            : `waiting-approval — asks: ${clip(value.parkedQuestion, 90)}`;
+    }
+    if (status === "completed" && value.calls > 0 && value.editsAttempted === 0) {
+        return `completed — but 0 of ${value.calls} calls attempted an edit; the run only read`;
+    }
+    if (status === "completed" && output !== undefined && output.length > 0) {
+        return `completed — ${clip(firstLine(output), 100)}`;
+    }
+    return status;
+};
+const label = (name) => name.padEnd(10);
+/**
+ * Renders the diagnosis card for one run: verdict, activity evidence, tokens,
+ * cost when any call was priced, refusals, cause, and output.
+ *
+ * @param subject the run being diagnosed
+ * @param value the digest computed from its events
+ * @since 1.0.0
+ * @category rendering
+ */
+export const render = (subject, value) => {
+    const output = resolvedOutput(value);
+    const lines = [
+        `${label("Verdict")}${verdict(value)}`,
+        `${label("Run")}${subject.runId}${subject.flowId === undefined ? "" : ` · ${subject.flowId}`}${value.seat === undefined ? "" : ` · ${value.seat}`} · ${duration(value)}`,
+        `${label("Activity")}${value.turns} turns · ${value.calls} calls (${value.callsFailed} refused) · edits ${value.editsSucceeded}/${value.editsAttempted}`,
+        `${label("Tokens")}${value.inputTokens} in / ${value.outputTokens} out`,
+        ...(value.costUsd > 0 ? [`${label("Cost")}${usd(value.costUsd)}`] : [])
+    ];
+    for (const [index, refusal] of value.refusals.slice(0, 3).entries()) {
+        lines.push(`${label(index === 0 ? "Refusals" : "")}${refusal.count}× ${clip(refusal.message, 110)}`);
+    }
+    if (value.cause !== undefined)
+        lines.push(`${label("Cause")}${clip(firstLine(value.cause), 120)}`);
+    if (output !== undefined && output.length > 0) {
+        lines.push(`${label("Output")}${clip(firstLine(output), 120)}`);
+    }
+    return lines.join("\n");
+};
+/**
+ * A digest of no events at all: the identity {@link combine} folds onto.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export const emptyDigest = () => digest([]);
+const earliest = (left, right) => left === undefined ? right : right === undefined ? left : Math.min(left, right);
+const latest = (left, right) => left === undefined ? right : right === undefined ? left : Math.max(left, right);
+/**
+ * Folds two digests of adjacent event ranges into the digest of both.
+ *
+ * `digest` is a left fold over an ordered range, so the digest of a whole
+ * journal is the digest of its prefix combined with the digest of its
+ * remainder. That identity is what lets a bounded reader keep exact counters
+ * for a run whose journal it cannot hold: it folds the events it drops into a
+ * carry digest and combines that carry with the digest of the window it kept.
+ *
+ * Used for contributions that do not overlap. Written fields may deliberately
+ * clear an older value. Refusal counts merge and re-sort. The span widens.
+ *
+ * @param earlier the digest of the earlier range
+ * @param later the digest of the range that follows it
+ * @since 1.0.0
+ * @category constructors
+ */
+const combinePlain = (earlier, later, writes) => {
+    const counts = new Map();
+    for (const refusal of [...earlier.refusals, ...later.refusals]) {
+        counts.set(refusal.message, (counts.get(refusal.message) ?? 0) + refusal.count);
+    }
+    return {
+        status: later.status ?? earlier.status,
+        cause: writes.cause ? later.cause : earlier.cause,
+        fault: writes.cause || (later.status !== undefined && later.status !== "failed") ? later.fault : earlier.fault,
+        seat: later.seat ?? earlier.seat,
+        turns: earlier.turns + later.turns,
+        calls: earlier.calls + later.calls,
+        callsFailed: earlier.callsFailed + later.callsFailed,
+        editsAttempted: earlier.editsAttempted + later.editsAttempted,
+        editsSucceeded: earlier.editsSucceeded + later.editsSucceeded,
+        refusals: [...counts.entries()]
+            .map(([message, count]) => ({ message, count }))
+            .sort((left, right) => right.count - left.count),
+        inputTokens: earlier.inputTokens + later.inputTokens,
+        outputTokens: earlier.outputTokens + later.outputTokens,
+        costUsd: earlier.costUsd + later.costUsd,
+        finalOutput: writes.finalOutput ? later.finalOutput : earlier.finalOutput,
+        nativeResolution: NativeResolution.combine(earlier.nativeResolution, later.nativeResolution),
+        parkedQuestion: writes.parkedQuestion ? later.parkedQuestion : earlier.parkedQuestion,
+        startedAt: earliest(earlier.startedAt, later.startedAt),
+        endedAt: latest(earlier.endedAt, later.endedAt)
+    };
+};
+const stateOf = (value) => digestStates.get(value) ?? {
+    base: value,
+    writes: {
+        cause: value.cause !== undefined,
+        finalOutput: value.finalOutput !== undefined,
+        parkedQuestion: value.parkedQuestion !== undefined
+    },
+    baseSeatOrdinal: value.seat === undefined ? undefined : 0,
+    baseRefusals: new Map(value.refusals.map((refusal) => [refusal.message, 0])),
+    indexes: emptyIndexes(),
+    contributions: HashMap.empty(),
+    contributionBytes: 0,
+    length: 1
+};
+/** Rebuild only scalar facts; keyed observations never own root result/state fields. */
+const combinedFacts = (state) => {
+    const result = { ...state.base };
+    let seatOrdinal = state.baseSeatOrdinal ?? -1;
+    const refusals = new Map(state.base.refusals.map((refusal) => [refusal.message, {
+            count: refusal.count,
+            ordinal: state.baseRefusals.get(refusal.message)
+        }]));
+    for (const [, contribution] of state.contributions) {
+        const value = contribution.value;
+        for (const key of counters)
+            result[key] += value[key] ?? 0;
+        if (value.seat !== undefined && contribution.ordinal > seatOrdinal) {
+            result.seat = value.seat;
+            seatOrdinal = contribution.ordinal;
+        }
+        result.startedAt = earliest(result.startedAt, value.startedAt);
+        result.endedAt = latest(result.endedAt, value.endedAt);
+        for (const refusal of value.refusals ?? []) {
+            const previous = refusals.get(refusal.message);
+            refusals.set(refusal.message, {
+                count: (previous?.count ?? 0) + refusal.count,
+                ordinal: Math.min(previous?.ordinal ?? contribution.ordinal, contribution.ordinal)
+            });
+        }
+    }
+    result.refusals = [...refusals].sort(([, left], [, right]) => right.count - left.count || left.ordinal - right.ordinal)
+        .map(([message, { count }]) => ({ message, count }));
+    return result;
+};
+/**
+ * Combines adjacent digests without counting an identified call or checkpoint
+ * twice. A later native fact replaces the earlier telemetry contribution.
+ * Identity state is private and must stay with the in-memory digest; a plain
+ * reconstructed Digest is treated as an already aggregated, unkeyed value.
+ * @category constructors
+ * @since 1.0.0
+ */
+export const combine = (earlier, later) => {
+    const left = stateOf(earlier);
+    const right = stateOf(later);
+    let contributions = left.contributions;
+    let indexes = left.indexes;
+    let contributionBytes = left.contributionBytes;
+    let accepted = HashMap.empty();
+    const corrected = { ...earlier };
+    for (const [key, value] of right.contributions) {
+        const previous = HashMap.get(contributions, key);
+        if (previous._tag === "Some" && (previous.value.authoritative || !value.authoritative))
+            continue;
+        if (previous._tag === "Some") {
+            const old = previous.value.value;
+            const next = value.value;
+            for (const counter of counters)
+                corrected[counter] += (next[counter] ?? 0) - (old[counter] ?? 0);
+        }
+        else
+            accepted = HashMap.set(accepted, key, value);
+        const contribution = {
+            ...value,
+            ordinal: previous._tag === "Some" ? previous.value.ordinal : left.length + value.ordinal
+        };
+        contributionBytes += encodedBytes([key, contribution]) -
+            (previous._tag === "Some" ? encodedBytes([key, previous.value]) : 0);
+        contributions = HashMap.set(contributions, key, contribution);
+        indexes = indexContribution(indexes, previous._tag === "Some" ? previous.value : undefined, contribution);
+    }
+    const baseRefusals = new Map(left.baseRefusals);
+    for (const [message, ordinal] of right.baseRefusals) {
+        if (!baseRefusals.has(message))
+            baseRefusals.set(message, left.length + ordinal);
+    }
+    const incomingComplete = HashMap.size(accepted) === HashMap.size(right.contributions);
+    const incoming = incomingComplete ? later : combinedFacts({ ...right, contributions: accepted });
+    const state = {
+        base: combinePlain(left.base, right.base, right.writes),
+        writes: {
+            cause: left.writes.cause || right.writes.cause,
+            finalOutput: left.writes.finalOutput || right.writes.finalOutput,
+            parkedQuestion: left.writes.parkedQuestion || right.writes.parkedQuestion
+        },
+        baseSeatOrdinal: right.baseSeatOrdinal === undefined ? left.baseSeatOrdinal : left.length + right.baseSeatOrdinal,
+        baseRefusals,
+        indexes,
+        contributions,
+        contributionBytes,
+        length: left.length + right.length
+    };
+    // Appending new identities (or replaying an existing one) should cost the
+    // incoming range, not re-fold the entire retained ledger on every eviction.
+    // Indexed timestamps and refusal positions handle native corrections without
+    // re-scanning all identities. Refusal rendering costs distinct messages.
+    const value = { ...combinePlain(corrected, incoming, right.writes) };
+    value.startedAt = state.base.startedAt;
+    value.endedAt = state.base.endedAt;
+    if (indexes.timings?.min !== undefined) {
+        value.startedAt = Math.min(value.startedAt ?? indexes.timings.min, indexes.timings.min);
+    }
+    if (indexes.timings?.max !== undefined) {
+        value.endedAt = Math.max(value.endedAt ?? indexes.timings.max, indexes.timings.max);
+    }
+    const refusals = new Map(state.base.refusals.map((refusal) => [refusal.message, {
+            count: refusal.count,
+            ordinal: baseRefusals.get(refusal.message)
+        }]));
+    for (const [message, tree] of indexes.refusals) {
+        const previous = refusals.get(message);
+        refusals.set(message, {
+            count: (previous?.count ?? 0) + tree.size,
+            ordinal: Math.min(previous?.ordinal ?? tree.first, tree.first)
+        });
+    }
+    value.refusals = [...refusals].sort(([, a], [, b]) => b.count - a.count || a.ordinal - b.ordinal)
+        .map(([message, { count }]) => ({ message, count }));
+    return remember(value, state);
+};
+//# sourceMappingURL=Diagnosis.js.map