@causal-order/monitor 0.0.9

package/.build/src/config.d.ts

@@ -0,0 +1 @@
+export { createDefaultMonitorConfig, type MonitorComponentHealthConfig, type MonitorConfig, type MonitorHealthConfig, type MonitorReplayConfig, type MonitorReservoirConfig, type MonitorThrottleConfig, type MonitorThrottleTierConfig, type MonitorTransportConfig, } from "./types/config.js";

package/.build/src/config.js

@@ -0,0 +1 @@
+export { createDefaultMonitorConfig, } from "./types/config.js";

package/.build/src/health/HealthTracker.d.ts

@@ -0,0 +1,12 @@
+import type { MonitorHealthConfig } from "../types/config.js";
+import type { MonitorComponent, MonitorHealthUpdate } from "../types/events.js";
+import type { MonitorComponentHealthSnapshot } from "../types/snapshots.js";
+export declare class HealthTracker {
+    #private;
+    constructor(config: MonitorHealthConfig, now: () => bigint);
+    getSnapshot(): Record<MonitorComponent, MonitorComponentHealthSnapshot>;
+    getComponentSnapshot(component: MonitorComponent): MonitorComponentHealthSnapshot;
+    updateComponentHealth(component: MonitorComponent, update: MonitorHealthUpdate): MonitorComponentHealthSnapshot;
+    observeHeartbeat(component: MonitorComponent, observedAt?: bigint, details?: Record<string, unknown>): MonitorComponentHealthSnapshot;
+    refreshStates(at?: bigint): Record<MonitorComponent, MonitorComponentHealthSnapshot>;
+}

package/.build/src/health/HealthTracker.js

@@ -0,0 +1,133 @@
+function createComponentSnapshot(component, observedAt) {
+    return {
+        component,
+        state: "online",
+        observedAt,
+        lastChangedAt: observedAt,
+        reasonCode: null,
+        details: {},
+    };
+}
+export class HealthTracker {
+    #config;
+    #now;
+    #components;
+    constructor(config, now) {
+        this.#config = config;
+        this.#now = now;
+        const observedAt = now();
+        this.#components = {
+            transport: {
+                snapshot: createComponentSnapshot("transport", observedAt),
+                lastHeartbeatAt: observedAt,
+            },
+            dedupe: {
+                snapshot: createComponentSnapshot("dedupe", observedAt),
+                lastHeartbeatAt: observedAt,
+            },
+            "causal-order": {
+                snapshot: createComponentSnapshot("causal-order", observedAt),
+                lastHeartbeatAt: observedAt,
+            },
+        };
+    }
+    getSnapshot() {
+        return {
+            transport: {
+                ...this.#components.transport.snapshot,
+                details: { ...this.#components.transport.snapshot.details },
+            },
+            dedupe: {
+                ...this.#components.dedupe.snapshot,
+                details: { ...this.#components.dedupe.snapshot.details },
+            },
+            "causal-order": {
+                ...this.#components["causal-order"].snapshot,
+                details: { ...this.#components["causal-order"].snapshot.details },
+            },
+        };
+    }
+    getComponentSnapshot(component) {
+        const snapshot = this.#components[component].snapshot;
+        return {
+            ...snapshot,
+            details: { ...snapshot.details },
+        };
+    }
+    updateComponentHealth(component, update) {
+        const componentState = this.#components[component];
+        const observedAt = update.observedAt ?? this.#now();
+        const previous = componentState.snapshot;
+        const nextState = update.state;
+        componentState.snapshot = {
+            component,
+            state: nextState,
+            observedAt,
+            lastChangedAt: previous.state === nextState ? previous.lastChangedAt : observedAt,
+            reasonCode: update.reasonCode ?? null,
+            details: update.details ?? {},
+        };
+        if (nextState !== "offline") {
+            componentState.lastHeartbeatAt = observedAt;
+        }
+        return this.getComponentSnapshot(component);
+    }
+    observeHeartbeat(component, observedAt = this.#now(), details = {}) {
+        const componentState = this.#components[component];
+        componentState.lastHeartbeatAt = observedAt;
+        return this.updateComponentHealth(component, {
+            state: "online",
+            observedAt,
+            reasonCode: "heartbeat",
+            details,
+        });
+    }
+    refreshStates(at = this.#now()) {
+        const componentNames = [
+            "transport",
+            "dedupe",
+            "causal-order",
+        ];
+        for (const component of componentNames) {
+            const componentState = this.#components[component];
+            const elapsed = at - componentState.lastHeartbeatAt;
+            const thresholds = this.#resolveThresholds(component);
+            const nextState = this.#resolveStateFromElapsed(elapsed, thresholds);
+            if (nextState !== componentState.snapshot.state) {
+                this.updateComponentHealth(component, {
+                    state: nextState,
+                    observedAt: at,
+                    reasonCode: "heartbeat_timeout",
+                    details: {
+                        elapsedSinceHeartbeatMs: elapsed.toString(),
+                    },
+                });
+            }
+            else {
+                componentState.snapshot = {
+                    ...componentState.snapshot,
+                    observedAt: at,
+                };
+            }
+        }
+        return this.getSnapshot();
+    }
+    #resolveThresholds(component) {
+        if (component === "transport") {
+            return this.#config.transport;
+        }
+        if (component === "dedupe") {
+            return this.#config.dedupe;
+        }
+        return this.#config.causalOrder;
+    }
+    #resolveStateFromElapsed(elapsed, thresholds) {
+        if (elapsed >= thresholds.offlineAfterMs) {
+            return "offline";
+        }
+        if (elapsed >= thresholds.degradedAfterMs) {
+            return "degraded";
+        }
+        return "online";
+    }
+}

package/.build/src/health.d.ts

@@ -0,0 +1 @@
+export { HealthTracker } from "./health/HealthTracker.js";

package/.build/src/health.js

@@ -0,0 +1 @@
+export { HealthTracker } from "./health/HealthTracker.js";

package/.build/src/index.d.ts

@@ -0,0 +1,16 @@
+export declare const monitorPackageVersion = "0.0.9";
+export type MonitorImplementationStatus = "replay_operational";
+export declare const monitorImplementationStatus: MonitorImplementationStatus;
+export { createDefaultMonitorConfig, type MonitorComponentHealthConfig, type MonitorConfig, type MonitorHealthConfig, type MonitorReplayConfig, type MonitorReservoirConfig, type MonitorThrottleConfig, type MonitorThrottleTierConfig, type MonitorTransportConfig, } from "./types/config.js";
+export { type MonitorClock, type MonitorComponent, type MonitorDeliveryMode, type MonitorHealthState, type MonitorHealthUpdate, type MonitorIngressAction, type MonitorIngressDecision, type MonitorIngressEvent, type MonitorPeerState, type MonitorPeerStateEvent, type MonitorReplaySessionState, type MonitorReplayTargetPath, type MonitorRoutingMode, type MonitorSourcePath, type MonitorThrottleTier, } from "./types/events.js";
+export { type MonitorOperationalState, type InspectedMonitorSnapshot, type MonitorComponentHealthSnapshot, type MonitorSnapshot, type ReplaySessionSnapshot, type ReservoirStats, } from "./types/snapshots.js";
+export { inspectMonitorSnapshot } from "./inspect/inspectMonitorSnapshot.js";
+export { HealthTracker } from "./health/HealthTracker.js";
+export { ReplayCoordinator, type ReplayBatch } from "./replay/ReplayCoordinator.js";
+export { DeliveryRouter } from "./routing/DeliveryRouter.js";
+export { createMonitorRuntime } from "./runtime/createMonitorRuntime.js";
+export { MonitorRuntime } from "./runtime/MonitorRuntime.js";
+export { SQLiteReservoir, type ReservoirReplayEntry, } from "./storage/SQLiteReservoir.js";
+export { TransportMonitorAdapter, type MonitorAdapterForwardContext, type MonitorAdapterHandlers, type MonitorIngestResult, type ReplayPumpResult, } from "./transport/TransportMonitorAdapter.js";
+export { monitorHarnessArtifacts, monitorHarnessScenarios, type MonitorHarnessAdapterContract, type MonitorHarnessArtifactSpec, type MonitorHarnessExpectation, type MonitorHarnessRuntimeKind, type MonitorHarnessScenarioDefinition, type MonitorHarnessScenarioId, } from "./testing/monitorHarness.js";
+export { ThrottleController } from "./throttle/ThrottleController.js";

package/.build/src/index.js

@@ -0,0 +1,15 @@
+export const monitorPackageVersion = "0.0.9";
+export const monitorImplementationStatus = "replay_operational";
+export { createDefaultMonitorConfig, } from "./types/config.js";
+export {} from "./types/events.js";
+export {} from "./types/snapshots.js";
+export { inspectMonitorSnapshot } from "./inspect/inspectMonitorSnapshot.js";
+export { HealthTracker } from "./health/HealthTracker.js";
+export { ReplayCoordinator } from "./replay/ReplayCoordinator.js";
+export { DeliveryRouter } from "./routing/DeliveryRouter.js";
+export { createMonitorRuntime } from "./runtime/createMonitorRuntime.js";
+export { MonitorRuntime } from "./runtime/MonitorRuntime.js";
+export { SQLiteReservoir, } from "./storage/SQLiteReservoir.js";
+export { TransportMonitorAdapter, } from "./transport/TransportMonitorAdapter.js";
+export { monitorHarnessArtifacts, monitorHarnessScenarios, } from "./testing/monitorHarness.js";
+export { ThrottleController } from "./throttle/ThrottleController.js";

package/.build/src/inspect/inspectMonitorSnapshot.d.ts

@@ -0,0 +1,2 @@
+import type { InspectedMonitorSnapshot, MonitorSnapshot } from "../types/snapshots.js";
+export declare function inspectMonitorSnapshot(snapshot: MonitorSnapshot): InspectedMonitorSnapshot;

package/.build/src/inspect/inspectMonitorSnapshot.js

@@ -0,0 +1,79 @@
+function deriveOperationalState(snapshot, replayRetryBackoffActive) {
+    if (replayRetryBackoffActive) {
+        return "replay_retry_waiting";
+    }
+    if (snapshot.replay.state === "queued" || snapshot.replay.state === "running") {
+        return "replay_draining";
+    }
+    if (snapshot.replay.state === "completed") {
+        return "recovery_confirming";
+    }
+    if (snapshot.routingMode === "order_buffer_only" ||
+        snapshot.routingMode === "full_outage_buffer") {
+        return "buffering_only";
+    }
+    if (snapshot.routingMode === "dedupe_bypass_throttled") {
+        return "degraded_live";
+    }
+    return "healthy_live";
+}
+function deriveLiveFlowGateReason(snapshot, replayRetryBackoffActive) {
+    if (replayRetryBackoffActive) {
+        return "replay retry backoff in progress";
+    }
+    if (snapshot.replay.state === "queued" || snapshot.replay.state === "running") {
+        return "replay backlog is draining";
+    }
+    if (snapshot.replay.state === "completed") {
+        return "post-replay health confirmation is still in progress";
+    }
+    return null;
+}
+export function inspectMonitorSnapshot(snapshot) {
+    const unhealthyComponents = Object.values(snapshot.components)
+        .filter((component) => component.state !== "online")
+        .map((component) => component.component);
+    const replayRetryBackoffActive = snapshot.replay.nextRetryAt !== null &&
+        snapshot.replay.nextRetryAt > snapshot.generatedAt;
+    const operationalState = deriveOperationalState(snapshot, replayRetryBackoffActive);
+    const liveFlowGateReason = deriveLiveFlowGateReason(snapshot, replayRetryBackoffActive);
+    const liveFlowGateClosed = liveFlowGateReason !== null;
+    const replayReadyRows = Math.max(0, snapshot.reservoir.totalPendingRows - snapshot.reservoir.retryWaitingRows);
+    const replayProgressBase = snapshot.replay.deliveredEventCount + snapshot.reservoir.totalPendingRows;
+    const replayProgressPercent = replayProgressBase === 0
+        ? null
+        : Math.min(100, Math.max(0, Math.round((snapshot.replay.deliveredEventCount / replayProgressBase) * 100)));
+    const replayRetryDelayMs = snapshot.replay.nextRetryAt !== null &&
+        snapshot.replay.nextRetryAt > snapshot.generatedAt
+        ? snapshot.replay.nextRetryAt - snapshot.generatedAt
+        : null;
+    const requiresOperatorAttention = unhealthyComponents.length > 0 ||
+        snapshot.replay.state === "failed" ||
+        snapshot.replay.state === "aborted" ||
+        snapshot.reservoir.retryWaitingRows > 0 ||
+        snapshot.reservoir.totalPendingRows > 0;
+    return {
+        generatedAt: snapshot.generatedAt,
+        operationalState,
+        routingMode: snapshot.routingMode,
+        throttleTier: snapshot.throttleTier,
+        unhealthyComponents,
+        requiresOperatorAttention,
+        liveFlowGateClosed,
+        liveFlowGateReason,
+        totalPendingRows: snapshot.reservoir.totalPendingRows,
+        oldestPendingAgeMs: snapshot.reservoir.oldestPendingAgeMs,
+        replayReadyRows,
+        retryWaitingRows: snapshot.reservoir.retryWaitingRows,
+        earliestRetryAt: snapshot.reservoir.earliestRetryAt,
+        replayState: snapshot.replay.state,
+        replayBacklogRemainingRows: snapshot.reservoir.totalPendingRows,
+        replayProgressPercent,
+        replayQueuedEventCount: snapshot.replay.queuedEventCount,
+        replayDeliveredEventCount: snapshot.replay.deliveredEventCount,
+        replayNextRetryAt: snapshot.replay.nextRetryAt,
+        replayRetryDelayMs,
+        replayConsecutiveFailureCount: snapshot.replay.consecutiveFailureCount,
+        replayRetryBackoffActive,
+    };
+}

package/.build/src/inspect.d.ts

@@ -0,0 +1 @@
+export { inspectMonitorSnapshot } from "./inspect/inspectMonitorSnapshot.js";

package/.build/src/inspect.js

@@ -0,0 +1 @@
+export { inspectMonitorSnapshot } from "./inspect/inspectMonitorSnapshot.js";

package/.build/src/replay/ReplayCoordinator.d.ts

@@ -0,0 +1,24 @@
+import type { MonitorReplayConfig } from "../types/config.js";
+import type { MonitorComponent, MonitorHealthState } from "../types/events.js";
+import type { ReplaySessionSnapshot } from "../types/snapshots.js";
+import { SQLiteReservoir, type ReservoirReplayEntry } from "../storage/SQLiteReservoir.js";
+export interface ReplayBatch {
+    session: ReplaySessionSnapshot;
+    entries: ReservoirReplayEntry[];
+    isDrainComplete: boolean;
+}
+export declare class ReplayCoordinator {
+    #private;
+    constructor(config: MonitorReplayConfig, reservoir: SQLiteReservoir, now: () => bigint);
+    getSnapshot(): ReplaySessionSnapshot;
+    isGateClosed(): boolean;
+    queueIfNeeded(): ReplaySessionSnapshot;
+    start(): ReplaySessionSnapshot;
+    claimNextBatch(limit: number): ReplayBatch;
+    acknowledgeBatch(rowIds: ReadonlyArray<number>): ReplaySessionSnapshot;
+    fail(error: string, rowIds?: ReadonlyArray<number>): ReplaySessionSnapshot;
+    abort(reason: string, rowIds?: ReadonlyArray<number>): ReplaySessionSnapshot;
+    complete(): ReplaySessionSnapshot;
+    observeRecoveryHeartbeat(component: MonitorComponent, state: MonitorHealthState, allHealthy: boolean): ReplaySessionSnapshot;
+    resetToIdle(): ReplaySessionSnapshot;
+}

package/.build/src/replay/ReplayCoordinator.js

@@ -0,0 +1,205 @@
+import { SQLiteReservoir, } from "../storage/SQLiteReservoir.js";
+function createSnapshot(requiredRecoveryHeartbeats) {
+    return {
+        state: "idle",
+        targetPath: "dedupe_then_order",
+        queuedEventCount: 0,
+        deliveredEventCount: 0,
+        startedAt: null,
+        endedAt: null,
+        lastError: null,
+        nextRetryAt: null,
+        consecutiveFailureCount: 0,
+        recoveryHeartbeatCount: 0,
+        requiredRecoveryHeartbeats,
+    };
+}
+export class ReplayCoordinator {
+    #config;
+    #reservoir;
+    #now;
+    #snapshot;
+    constructor(config, reservoir, now) {
+        this.#config = config;
+        this.#reservoir = reservoir;
+        this.#now = now;
+        this.#snapshot = createSnapshot(config.healthConfirmationHeartbeats);
+    }
+    getSnapshot() {
+        return { ...this.#snapshot };
+    }
+    isGateClosed() {
+        return (this.#snapshot.state === "queued" ||
+            this.#snapshot.state === "running" ||
+            this.#snapshot.state === "failed" ||
+            (this.#snapshot.state === "completed" &&
+                this.#snapshot.recoveryHeartbeatCount <
+                    this.#snapshot.requiredRecoveryHeartbeats));
+    }
+    queueIfNeeded() {
+        const backlog = this.#reservoir.getStats().totalPendingRows;
+        if (backlog === 0) {
+            return this.getSnapshot();
+        }
+        if (this.#snapshot.state === "running" || this.#snapshot.state === "queued") {
+            return this.#commit({
+                ...this.#snapshot,
+                queuedEventCount: Math.max(this.#snapshot.queuedEventCount, backlog),
+            });
+        }
+        if (this.#snapshot.state === "failed" &&
+            this.#snapshot.nextRetryAt !== null &&
+            this.#now() < this.#snapshot.nextRetryAt) {
+            return this.#commit({
+                ...this.#snapshot,
+                queuedEventCount: Math.max(this.#snapshot.queuedEventCount, backlog),
+            });
+        }
+        return this.#commit({
+            state: "queued",
+            targetPath: "dedupe_then_order",
+            queuedEventCount: backlog,
+            deliveredEventCount: 0,
+            startedAt: null,
+            endedAt: null,
+            lastError: null,
+            nextRetryAt: null,
+            consecutiveFailureCount: this.#snapshot.state === "failed"
+                ? this.#snapshot.consecutiveFailureCount
+                : 0,
+            recoveryHeartbeatCount: 0,
+            requiredRecoveryHeartbeats: this.#config.healthConfirmationHeartbeats,
+        });
+    }
+    start() {
+        const backlog = this.#reservoir.getStats().totalPendingRows;
+        if (backlog === 0) {
+            return this.resetToIdle();
+        }
+        if (this.#snapshot.state === "running") {
+            return this.getSnapshot();
+        }
+        if (this.#snapshot.state !== "queued" && this.#snapshot.state !== "failed") {
+            throw new Error(`Cannot start replay from state '${this.#snapshot.state}'. Queue replay first.`);
+        }
+        return this.#commit({
+            state: "running",
+            targetPath: "dedupe_then_order",
+            queuedEventCount: backlog,
+            deliveredEventCount: 0,
+            startedAt: this.#now(),
+            endedAt: null,
+            lastError: null,
+            nextRetryAt: null,
+            recoveryHeartbeatCount: 0,
+            requiredRecoveryHeartbeats: this.#config.healthConfirmationHeartbeats,
+            consecutiveFailureCount: this.#snapshot.state === "failed"
+                ? this.#snapshot.consecutiveFailureCount
+                : 0,
+        });
+    }
+    claimNextBatch(limit) {
+        if (this.#snapshot.state === "queued") {
+            this.start();
+        }
+        if (this.#snapshot.state !== "running") {
+            throw new Error(`Cannot claim replay batch while replay is '${this.#snapshot.state}'.`);
+        }
+        const entries = this.#reservoir.claimReplayBatch(limit);
+        if (entries.length === 0) {
+            const remainingRows = this.#reservoir.getStats().totalPendingRows;
+            if (remainingRows === 0) {
+                return {
+                    session: this.complete(),
+                    entries: [],
+                    isDrainComplete: true,
+                };
+            }
+        }
+        return {
+            session: this.getSnapshot(),
+            entries,
+            isDrainComplete: false,
+        };
+    }
+    acknowledgeBatch(rowIds) {
+        const deliveredNow = this.#reservoir.markReplayBatchDelivered(rowIds);
+        const remainingRows = this.#reservoir.getStats().totalPendingRows;
+        const deliveredEventCount = this.#snapshot.deliveredEventCount + deliveredNow;
+        const nextSnapshot = this.#commit({
+            ...this.#snapshot,
+            deliveredEventCount,
+            queuedEventCount: deliveredEventCount + remainingRows,
+        });
+        if (remainingRows === 0 && nextSnapshot.state === "running") {
+            return this.complete();
+        }
+        return nextSnapshot;
+    }
+    fail(error, rowIds = []) {
+        const now = this.#now();
+        const nextRetryAt = now + this.#config.retryBackoffMs;
+        this.#reservoir.resetReplayBatchToPending(rowIds, nextRetryAt);
+        return this.#commit({
+            ...this.#snapshot,
+            state: "failed",
+            endedAt: now,
+            lastError: error,
+            nextRetryAt,
+            consecutiveFailureCount: this.#snapshot.consecutiveFailureCount + 1,
+        });
+    }
+    abort(reason, rowIds = []) {
+        this.#reservoir.resetReplayBatchToPending(rowIds);
+        return this.#commit({
+            ...this.#snapshot,
+            state: "aborted",
+            endedAt: this.#now(),
+            lastError: reason,
+            nextRetryAt: null,
+        });
+    }
+    complete() {
+        return this.#commit({
+            ...this.#snapshot,
+            state: "completed",
+            queuedEventCount: this.#snapshot.deliveredEventCount,
+            endedAt: this.#now(),
+            lastError: null,
+            nextRetryAt: null,
+            recoveryHeartbeatCount: 0,
+        });
+    }
+    observeRecoveryHeartbeat(component, state, allHealthy) {
+        if (this.#snapshot.state !== "completed") {
+            return this.getSnapshot();
+        }
+        if (component === "transport") {
+            return this.getSnapshot();
+        }
+        if (state !== "online" || !allHealthy) {
+            return this.#commit({
+                ...this.#snapshot,
+                recoveryHeartbeatCount: 0,
+            });
+        }
+        const recoveryHeartbeatCount = this.#snapshot.recoveryHeartbeatCount + 1;
+        const nextSnapshot = this.#commit({
+            ...this.#snapshot,
+            recoveryHeartbeatCount,
+        });
+        if (recoveryHeartbeatCount >= this.#config.healthConfirmationHeartbeats &&
+            this.#reservoir.getStats().totalPendingRows === 0) {
+            return this.resetToIdle();
+        }
+        return nextSnapshot;
+    }
+    resetToIdle() {
+        return this.#commit(createSnapshot(this.#config.healthConfirmationHeartbeats));
+    }
+    #commit(snapshot) {
+        this.#snapshot = { ...snapshot };
+        this.#reservoir.recordReplaySnapshot(this.#snapshot);
+        return this.getSnapshot();
+    }
+}

package/.build/src/replay.d.ts

@@ -0,0 +1 @@
+export { ReplayCoordinator, type ReplayBatch } from "./replay/ReplayCoordinator.js";

package/.build/src/replay.js

@@ -0,0 +1 @@
+export { ReplayCoordinator } from "./replay/ReplayCoordinator.js";

package/.build/src/routing/DeliveryRouter.d.ts

@@ -0,0 +1,8 @@
+import { ThrottleController } from "../throttle/ThrottleController.js";
+import type { MonitorIngressDecision, MonitorRoutingMode } from "../types/events.js";
+import type { ReservoirStats } from "../types/snapshots.js";
+export declare class DeliveryRouter {
+    #private;
+    constructor(throttleController: ThrottleController);
+    decideIngress(routingMode: MonitorRoutingMode, reservoir: ReservoirStats): MonitorIngressDecision;
+}

package/.build/src/routing/DeliveryRouter.js

@@ -0,0 +1,48 @@
+import { ThrottleController } from "../throttle/ThrottleController.js";
+export class DeliveryRouter {
+    #throttleController;
+    constructor(throttleController) {
+        this.#throttleController = throttleController;
+    }
+    decideIngress(routingMode, reservoir) {
+        const throttle = this.#throttleController.decide(routingMode, reservoir);
+        if (throttle.tier === "paused") {
+            return {
+                action: routingMode === "full_outage_buffer" || routingMode === "order_buffer_only"
+                    ? "buffer_only"
+                    : "pause",
+                routingMode,
+                deliveryMode: this.#resolveDeliveryMode(routingMode),
+                throttleTier: throttle.tier,
+                targetEventsPerSecond: throttle.targetEventsPerSecond,
+                targetBatchSize: throttle.targetBatchSize,
+                reason: throttle.reason,
+            };
+        }
+        return {
+            action: routingMode === "full_outage_buffer" || routingMode === "order_buffer_only"
+                ? "buffer_only"
+                : "accept",
+            routingMode,
+            deliveryMode: this.#resolveDeliveryMode(routingMode),
+            throttleTier: throttle.tier,
+            targetEventsPerSecond: throttle.targetEventsPerSecond,
+            targetBatchSize: throttle.targetBatchSize,
+            reason: throttle.reason,
+        };
+    }
+    #resolveDeliveryMode(routingMode) {
+        switch (routingMode) {
+            case "dedupe_bypass_throttled":
+                return "dedupe_bypass";
+            case "order_buffer_only":
+                return "order_buffer_only";
+            case "full_outage_buffer":
+                return "full_outage_buffer";
+            case "replay_through_dedupe":
+                return "replay_through_dedupe";
+            default:
+                return "normal";
+        }
+    }
+}

package/.build/src/routing.d.ts

@@ -0,0 +1 @@
+export { DeliveryRouter } from "./routing/DeliveryRouter.js";

package/.build/src/routing.js

@@ -0,0 +1 @@
+export { DeliveryRouter } from "./routing/DeliveryRouter.js";

package/.build/src/runtime/MonitorRuntime.d.ts

@@ -0,0 +1,35 @@
+import { type MonitorConfig } from "../types/config.js";
+import type { MonitorComponent, MonitorIngressDecision, MonitorHealthUpdate, MonitorIngressEvent, MonitorThrottleTier } from "../types/events.js";
+import type { InspectedMonitorSnapshot, MonitorSnapshot, ReplaySessionSnapshot, ReservoirStats } from "../types/snapshots.js";
+export declare class MonitorRuntime {
+    #private;
+    constructor(config?: Partial<MonitorConfig>);
+    getConfig(): Readonly<MonitorConfig>;
+    getSnapshot(): MonitorSnapshot;
+    getInspectedSnapshot(): InspectedMonitorSnapshot;
+    getHealthSnapshot(): Record<MonitorComponent, import("../types/snapshots.js").MonitorComponentHealthSnapshot>;
+    getReservoirStats(): ReservoirStats;
+    getReplaySnapshot(): ReplaySessionSnapshot;
+    getIngressDecision(): MonitorIngressDecision;
+    updateComponentHealth(component: MonitorComponent, update: MonitorHealthUpdate): import("../types/snapshots.js").MonitorComponentHealthSnapshot;
+    observeHeartbeat(component: MonitorComponent, observedAt?: bigint, details?: Record<string, unknown>): import("../types/snapshots.js").MonitorComponentHealthSnapshot;
+    setThrottleTier(tier: MonitorThrottleTier): MonitorThrottleTier;
+    queueReplay(): ReplaySessionSnapshot;
+    startReplay(): ReplaySessionSnapshot;
+    claimReplayBatch(limit?: number): import("../replay/ReplayCoordinator.js").ReplayBatch;
+    acknowledgeReplayBatch(rowIds: ReadonlyArray<number>): ReplaySessionSnapshot;
+    acknowledgeIngressDelivery(rowIds: ReadonlyArray<number>): number;
+    failReplay(error: string, rowIds?: ReadonlyArray<number>): ReplaySessionSnapshot;
+    abortReplay(reason: string, rowIds?: ReadonlyArray<number>): ReplaySessionSnapshot;
+    ingestTransportEvent(event: MonitorIngressEvent, sourceStreamId?: string | null): {
+        rowId: number;
+        decision: MonitorIngressDecision;
+    };
+    observeDedupeEvent(event: MonitorIngressEvent, sourceStreamId?: string | null): number;
+    pruneReservoir(): {
+        markedDeadLetter: number;
+        deletedRows: number;
+    };
+    refreshHealthStates(at?: bigint): Record<MonitorComponent, import("../types/snapshots.js").MonitorComponentHealthSnapshot>;
+    close(): void;
+}