@causal-order/monitor 0.0.9

package/.build/src/storage/schema.js

@@ -0,0 +1,80 @@
+import Database from "better-sqlite3";
+export const MONITOR_SQLITE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS ingress_events (
+  monitor_ingest_seq INTEGER PRIMARY KEY AUTOINCREMENT,
+  id TEXT NOT NULL,
+  monitor_ingest_at_ms INTEGER NOT NULL,
+  source_node_id TEXT NOT NULL,
+  source_stream_id TEXT,
+  source_path TEXT NOT NULL,
+  event_id TEXT NOT NULL,
+  trace_id TEXT,
+  sequence TEXT,
+  logical_time_ms INTEGER NOT NULL,
+  payload_json TEXT NOT NULL,
+  payload_encoding TEXT NOT NULL DEFAULT 'json',
+  delivery_mode TEXT NOT NULL,
+  replay_state TEXT NOT NULL,
+  replay_attempts INTEGER NOT NULL DEFAULT 0,
+  retry_not_before_ms INTEGER,
+  expires_at_ms INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_ingress_events_expires_at
+  ON ingress_events(expires_at_ms);
+
+CREATE INDEX IF NOT EXISTS idx_ingress_events_replay_state
+  ON ingress_events(replay_state);
+
+CREATE INDEX IF NOT EXISTS idx_ingress_events_replay_retry
+  ON ingress_events(replay_state, retry_not_before_ms);
+
+CREATE INDEX IF NOT EXISTS idx_ingress_events_source_path
+  ON ingress_events(source_path);
+
+CREATE TABLE IF NOT EXISTS component_health_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  recorded_at_ms INTEGER NOT NULL,
+  component TEXT NOT NULL,
+  health_state TEXT NOT NULL,
+  reason_code TEXT,
+  details_json TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_component_health_log_component_time
+  ON component_health_log(component, recorded_at_ms);
+
+CREATE TABLE IF NOT EXISTS outage_windows (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  started_at_ms INTEGER NOT NULL,
+  ended_at_ms INTEGER,
+  dedupe_state TEXT NOT NULL,
+  causal_order_state TEXT NOT NULL,
+  buffer_mode TEXT NOT NULL,
+  notes_json TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS replay_sessions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  started_at_ms INTEGER,
+  ended_at_ms INTEGER,
+  target_path TEXT NOT NULL,
+  session_state TEXT NOT NULL,
+  event_count_attempted INTEGER NOT NULL DEFAULT 0,
+  event_count_delivered INTEGER NOT NULL DEFAULT 0,
+  error_count INTEGER NOT NULL DEFAULT 0,
+  details_json TEXT NOT NULL
+);
+`;
+export function applyMonitorSchema(db) {
+    db.exec(MONITOR_SQLITE_SCHEMA);
+    const ingressColumns = db
+        .prepare(`PRAGMA table_info(ingress_events)`)
+        .all();
+    const columnNames = new Set(ingressColumns
+        .map((column) => column.name)
+        .filter((name) => typeof name === "string"));
+    if (!columnNames.has("retry_not_before_ms")) {
+        db.exec(`ALTER TABLE ingress_events ADD COLUMN retry_not_before_ms INTEGER`);
+    }
+}

package/.build/src/storage.d.ts

@@ -0,0 +1 @@
+export { SQLiteReservoir, type ReservoirReplayEntry, } from "./storage/SQLiteReservoir.js";

package/.build/src/storage.js

@@ -0,0 +1 @@
+export { SQLiteReservoir, } from "./storage/SQLiteReservoir.js";

package/.build/src/testing/monitorHarness.d.ts

@@ -0,0 +1,27 @@
+export type MonitorHarnessScenarioId = "monitor-healthy-rolling-4h" | "monitor-transport-outage-burst" | "monitor-dedupe-outage" | "monitor-order-outage" | "monitor-dual-outage" | "monitor-recovery-through-dedupe";
+export type MonitorHarnessRuntimeKind = "deployment-runtime" | "adapter-runtime";
+export interface MonitorHarnessArtifactSpec {
+    fileName: string;
+    purpose: string;
+}
+export interface MonitorHarnessExpectation {
+    description: string;
+}
+export interface MonitorHarnessScenarioDefinition {
+    id: MonitorHarnessScenarioId;
+    runtimeKinds: ReadonlyArray<MonitorHarnessRuntimeKind>;
+    title: string;
+    description: string;
+    expectedArtifacts: ReadonlyArray<MonitorHarnessArtifactSpec>;
+    expectedRoutingModes: ReadonlyArray<string>;
+    expectations: ReadonlyArray<MonitorHarnessExpectation>;
+}
+export declare const monitorHarnessArtifacts: ReadonlyArray<MonitorHarnessArtifactSpec>;
+export declare const monitorHarnessScenarios: ReadonlyArray<MonitorHarnessScenarioDefinition>;
+export interface MonitorHarnessAdapterContract {
+    ingest(event: Record<string, unknown>): Promise<void> | void;
+    updateComponentHealth(component: "transport" | "dedupe" | "causal-order", state: string): void;
+    getSnapshot(): Record<string, unknown>;
+    reconcileRecovery?(): Promise<Record<string, unknown> | null> | Record<string, unknown> | null;
+    destroy(): void;
+}

package/.build/src/testing/monitorHarness.js

@@ -0,0 +1,98 @@
+export const monitorHarnessArtifacts = [
+    {
+        fileName: "monitor-heartbeats.ndjson",
+        purpose: "Component heartbeat and blackout timeline for transport, dedupe, and causal-order.",
+    },
+    {
+        fileName: "monitor-health.ndjson",
+        purpose: "Health-state transitions, routing changes, and throttle posture.",
+    },
+    {
+        fileName: "monitor-replay.ndjson",
+        purpose: "Replay session lifecycle, batch drain progress, and replay failures.",
+    },
+    {
+        fileName: "monitor-summary.json",
+        purpose: "Compact run summary with backlog, routing, replay, and retention signals.",
+    },
+];
+export const monitorHarnessScenarios = [
+    {
+        id: "monitor-healthy-rolling-4h",
+        runtimeKinds: ["deployment-runtime", "adapter-runtime"],
+        title: "Healthy rolling reservoir",
+        description: "Validates steady-state buffering, pruning, and health visibility with all downstream components online.",
+        expectedArtifacts: monitorHarnessArtifacts,
+        expectedRoutingModes: ["normal"],
+        expectations: [
+            { description: "rolling retention stays bounded at 4 hours" },
+            { description: "no replay session starts during healthy flow" },
+            { description: "throttle tier remains open for normal throughput" },
+        ],
+    },
+    {
+        id: "monitor-transport-outage-burst",
+        runtimeKinds: ["adapter-runtime"],
+        title: "Transport outage and reconnect burst",
+        description: "Exercises transport blackout visibility and reconnect burst control without inventing separate monitor logic in the harness.",
+        expectedArtifacts: monitorHarnessArtifacts,
+        expectedRoutingModes: ["normal", "order_buffer_only"],
+        expectations: [
+            { description: "transport blackout is visible in heartbeat artifacts" },
+            { description: "reconnect burst markers appear in health or summary output" },
+            { description: "recovery does not bypass monitor routing decisions" },
+        ],
+    },
+    {
+        id: "monitor-dedupe-outage",
+        runtimeKinds: ["deployment-runtime", "adapter-runtime"],
+        title: "Dedupe outage with throttled bypass",
+        description: "Verifies that monitor can continue feeding causal-order directly while slowing ingress when dedupe is offline.",
+        expectedArtifacts: monitorHarnessArtifacts,
+        expectedRoutingModes: ["dedupe_bypass_throttled"],
+        expectations: [
+            { description: "routing switches into dedupe bypass mode" },
+            { description: "throttle tier drops below open during bypass" },
+            { description: "buffer growth remains inspectable in summary output" },
+        ],
+    },
+    {
+        id: "monitor-order-outage",
+        runtimeKinds: ["deployment-runtime", "adapter-runtime"],
+        title: "Order outage with buffered recovery",
+        description: "Confirms backlog accumulation while causal-order is offline and replay once the normal path is restored.",
+        expectedArtifacts: monitorHarnessArtifacts,
+        expectedRoutingModes: ["order_buffer_only", "replay_through_dedupe"],
+        expectations: [
+            { description: "live ingress buffers instead of forwarding to causal-order" },
+            { description: "replay is recorded as a distinct recovery session" },
+            { description: "live flow reopens only after replay completion" },
+        ],
+    },
+    {
+        id: "monitor-dual-outage",
+        runtimeKinds: ["deployment-runtime", "adapter-runtime"],
+        title: "Dual outage with hard retention ceiling",
+        description: "Checks that monitor remains bounded when both dedupe and causal-order are unavailable.",
+        expectedArtifacts: monitorHarnessArtifacts,
+        expectedRoutingModes: ["full_outage_buffer", "replay_through_dedupe"],
+        expectations: [
+            { description: "buffer retention never exceeds the hard 6 hour ceiling" },
+            { description: "expired undeliverable rows are visible as dead-letter outcomes" },
+            { description: "recovery still returns through dedupe before normal reopen" },
+        ],
+    },
+    {
+        id: "monitor-recovery-through-dedupe",
+        runtimeKinds: ["deployment-runtime", "adapter-runtime"],
+        title: "Recovery through dedupe",
+        description: "Validates the key current-line rule that backlog replay always routes back through restored dedupe.",
+        expectedArtifacts: monitorHarnessArtifacts,
+        expectedRoutingModes: ["replay_through_dedupe", "normal"],
+        expectations: [
+            { description: "replay target stays on the dedupe then order path" },
+            { description: "replay drain reaches zero pending rows" },
+            { description: "health confirmation gate completes before live reopen" },
+        ],
+    },
+];

package/.build/src/throttle/ThrottleController.d.ts

@@ -0,0 +1,14 @@
+import type { MonitorThrottleConfig } from "../types/config.js";
+import type { MonitorRoutingMode, MonitorThrottleTier } from "../types/events.js";
+import type { ReservoirStats } from "../types/snapshots.js";
+export interface ThrottleDecision {
+    tier: MonitorThrottleTier;
+    targetEventsPerSecond: number;
+    targetBatchSize: number;
+    reason: string;
+}
+export declare class ThrottleController {
+    #private;
+    constructor(config: MonitorThrottleConfig);
+    decide(routingMode: MonitorRoutingMode, reservoir: ReservoirStats): ThrottleDecision;
+}

package/.build/src/throttle/ThrottleController.js

@@ -0,0 +1,51 @@
+export class ThrottleController {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    decide(routingMode, reservoir) {
+        if (routingMode === "full_outage_buffer" || routingMode === "order_buffer_only") {
+            return this.#toDecision("paused", "downstream ordering path unavailable");
+        }
+        if (routingMode === "replay_through_dedupe") {
+            return this.#toDecision("very_slow", "replay session active");
+        }
+        if (routingMode === "dedupe_bypass_throttled") {
+            if (reservoir.totalPendingRows >= 10_000) {
+                return this.#toDecision("paused", "dedupe bypass backlog exceeds hard safety threshold");
+            }
+            if (reservoir.totalPendingRows >= 2_000) {
+                return this.#toDecision("very_slow", "dedupe bypass backlog is elevated");
+            }
+            return this.#toDecision("slow", "dedupe offline, protect causal-order");
+        }
+        if (reservoir.totalPendingRows >= 20_000) {
+            return this.#toDecision("very_slow", "backlog remains very high");
+        }
+        if (reservoir.totalPendingRows >= 5_000) {
+            return this.#toDecision("slow", "backlog is elevated");
+        }
+        return this.#toDecision(this.#config.defaultTier, "normal operating posture");
+    }
+    #toDecision(tier, reason) {
+        const target = this.#resolveTierConfig(tier);
+        return {
+            tier,
+            targetEventsPerSecond: target.maxEventsPerSecond,
+            targetBatchSize: target.batchSize,
+            reason,
+        };
+    }
+    #resolveTierConfig(tier) {
+        switch (tier) {
+            case "slow":
+                return this.#config.slow;
+            case "very_slow":
+                return this.#config.verySlow;
+            case "paused":
+                return this.#config.paused;
+            default:
+                return this.#config.open;
+        }
+    }
+}

package/.build/src/throttle.d.ts

@@ -0,0 +1 @@
+export { ThrottleController, type ThrottleDecision, } from "./throttle/ThrottleController.js";

package/.build/src/throttle.js

@@ -0,0 +1 @@
+export { ThrottleController, } from "./throttle/ThrottleController.js";

package/.build/src/transport/TransportMonitorAdapter.d.ts

@@ -0,0 +1,42 @@
+import { MonitorRuntime } from "../runtime/MonitorRuntime.js";
+import type { MonitorConfig } from "../types/config.js";
+import type { MonitorComponent, MonitorDeliveryMode, MonitorIngressDecision, MonitorIngressEvent } from "../types/events.js";
+import type { InspectedMonitorSnapshot, MonitorSnapshot, ReplaySessionSnapshot } from "../types/snapshots.js";
+export interface MonitorAdapterForwardContext {
+    rowId: number;
+    sourceStreamId: string | null;
+    deliveryMode: MonitorDeliveryMode;
+    replay: boolean;
+}
+export interface MonitorAdapterHandlers {
+    deliverToDedupe: (event: MonitorIngressEvent, context: MonitorAdapterForwardContext) => Promise<void> | void;
+    deliverToOrder: (event: MonitorIngressEvent, context: MonitorAdapterForwardContext) => Promise<void> | void;
+    onBuffered?: (event: MonitorIngressEvent, decision: MonitorIngressDecision, rowId: number) => Promise<void> | void;
+    onDecision?: (event: MonitorIngressEvent, decision: MonitorIngressDecision, rowId: number) => Promise<void> | void;
+    onReplayStateChange?: (snapshot: ReplaySessionSnapshot) => Promise<void> | void;
+}
+export interface MonitorIngestResult {
+    rowId: number;
+    decision: MonitorIngressDecision;
+    forwardedTo: "dedupe" | "causal-order" | "buffer";
+}
+export interface ReplayPumpResult {
+    snapshot: ReplaySessionSnapshot;
+    claimedCount: number;
+    deliveredCount: number;
+    completed: boolean;
+}
+export declare class TransportMonitorAdapter {
+    #private;
+    constructor(handlers: MonitorAdapterHandlers, config?: Partial<MonitorConfig>);
+    getRuntime(): MonitorRuntime;
+    getSnapshot(): MonitorSnapshot;
+    getInspectedSnapshot(): InspectedMonitorSnapshot;
+    getReplaySnapshot(): ReplaySessionSnapshot;
+    updateComponentHealth(component: MonitorComponent, update: Parameters<MonitorRuntime["updateComponentHealth"]>[1]): import("../types/snapshots.js").MonitorComponentHealthSnapshot;
+    observeHeartbeat(component: MonitorComponent, observedAt?: bigint, details?: Record<string, unknown>): import("../types/snapshots.js").MonitorComponentHealthSnapshot;
+    ingest(event: MonitorIngressEvent, sourceStreamId?: string | null): Promise<MonitorIngestResult>;
+    pumpReplayBatch(limit?: number): Promise<ReplayPumpResult>;
+    reconcileRecovery(limit?: number): Promise<ReplayPumpResult | null>;
+    close(): void;
+}

package/.build/src/transport/TransportMonitorAdapter.js

@@ -0,0 +1,135 @@
+import { MonitorRuntime } from "../runtime/MonitorRuntime.js";
+export class TransportMonitorAdapter {
+    #runtime;
+    #handlers;
+    constructor(handlers, config = {}) {
+        this.#runtime = new MonitorRuntime(config);
+        this.#handlers = handlers;
+    }
+    getRuntime() {
+        return this.#runtime;
+    }
+    getSnapshot() {
+        return this.#runtime.getSnapshot();
+    }
+    getInspectedSnapshot() {
+        return this.#runtime.getInspectedSnapshot();
+    }
+    getReplaySnapshot() {
+        return this.#runtime.getReplaySnapshot();
+    }
+    updateComponentHealth(component, update) {
+        const snapshot = this.#runtime.updateComponentHealth(component, update);
+        void this.#notifyReplayChange();
+        return snapshot;
+    }
+    observeHeartbeat(component, observedAt, details) {
+        const snapshot = this.#runtime.observeHeartbeat(component, observedAt, details);
+        void this.#notifyReplayChange();
+        return snapshot;
+    }
+    async ingest(event, sourceStreamId) {
+        const { rowId, decision } = this.#runtime.ingestTransportEvent(event, sourceStreamId);
+        await this.#handlers.onDecision?.(event, decision, rowId);
+        if (decision.action === "buffer_only" || decision.action === "pause") {
+            await this.#handlers.onBuffered?.(event, decision, rowId);
+            return {
+                rowId,
+                decision,
+                forwardedTo: "buffer",
+            };
+        }
+        if (decision.deliveryMode === "dedupe_bypass") {
+            await this.#handlers.deliverToOrder(event, {
+                rowId,
+                sourceStreamId: sourceStreamId ?? null,
+                deliveryMode: decision.deliveryMode,
+                replay: false,
+            });
+            this.#runtime.acknowledgeIngressDelivery([rowId]);
+            return {
+                rowId,
+                decision,
+                forwardedTo: "causal-order",
+            };
+        }
+        await this.#handlers.deliverToDedupe(event, {
+            rowId,
+            sourceStreamId: sourceStreamId ?? null,
+            deliveryMode: decision.deliveryMode,
+            replay: false,
+        });
+        this.#runtime.acknowledgeIngressDelivery([rowId]);
+        return {
+            rowId,
+            decision,
+            forwardedTo: "dedupe",
+        };
+    }
+    async pumpReplayBatch(limit) {
+        const batch = this.#runtime.claimReplayBatch(limit);
+        await this.#notifyReplayChange();
+        if (batch.entries.length === 0) {
+            await this.#notifyReplayChange();
+            return {
+                snapshot: this.#runtime.getReplaySnapshot(),
+                claimedCount: 0,
+                deliveredCount: 0,
+                completed: batch.isDrainComplete,
+            };
+        }
+        const claimedRowIds = [];
+        try {
+            for (const entry of batch.entries) {
+                claimedRowIds.push(entry.rowId);
+                await this.#handlers.deliverToDedupe(entry.event, {
+                    rowId: entry.rowId,
+                    sourceStreamId: entry.sourceStreamId,
+                    deliveryMode: "replay_through_dedupe",
+                    replay: true,
+                });
+            }
+            const snapshot = this.#runtime.acknowledgeReplayBatch(claimedRowIds);
+            await this.#notifyReplayChange();
+            return {
+                snapshot,
+                claimedCount: claimedRowIds.length,
+                deliveredCount: claimedRowIds.length,
+                completed: snapshot.state === "completed" || snapshot.state === "idle",
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "unknown replay failure";
+            const snapshot = this.#runtime.failReplay(message, claimedRowIds);
+            await this.#notifyReplayChange();
+            return {
+                snapshot,
+                claimedCount: claimedRowIds.length,
+                deliveredCount: 0,
+                completed: false,
+            };
+        }
+    }
+    async reconcileRecovery(limit) {
+        const snapshot = this.#runtime.getReplaySnapshot();
+        const backlog = this.#runtime.getReservoirStats().totalPendingRows;
+        if (backlog === 0) {
+            return null;
+        }
+        if (snapshot.state === "idle" || snapshot.state === "failed") {
+            this.#runtime.queueReplay();
+            await this.#notifyReplayChange();
+        }
+        const nextSnapshot = this.#runtime.getReplaySnapshot();
+        if (nextSnapshot.state !== "queued" && nextSnapshot.state !== "running") {
+            return null;
+        }
+        return this.pumpReplayBatch(limit);
+    }
+    close() {
+        this.#runtime.close();
+    }
+    async #notifyReplayChange() {
+        await this.#handlers.onReplayStateChange?.(this.#runtime.getReplaySnapshot());
+    }
+}

package/.build/src/transport.d.ts

@@ -0,0 +1 @@
+export { TransportMonitorAdapter, type MonitorAdapterForwardContext, type MonitorAdapterHandlers, type MonitorIngestResult, type ReplayPumpResult, } from "./transport/TransportMonitorAdapter.js";

package/.build/src/transport.js

@@ -0,0 +1 @@
+export { TransportMonitorAdapter, } from "./transport/TransportMonitorAdapter.js";

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

@@ -0,0 +1,46 @@
+import type { MonitorThrottleTier } from "./events.js";
+export interface MonitorReservoirConfig {
+    databasePath: string;
+    rollingBufferWindowMs: bigint;
+    fullOutageMaxWindowMs: bigint;
+    pruneIntervalMs: bigint;
+}
+export interface MonitorTransportConfig {
+    heartbeatGraceMs: bigint;
+    reconnectBurstWindowMs: bigint;
+    sourceLabel?: string;
+}
+export interface MonitorComponentHealthConfig {
+    degradedAfterMs: bigint;
+    offlineAfterMs: bigint;
+}
+export interface MonitorHealthConfig {
+    transport: MonitorComponentHealthConfig;
+    dedupe: MonitorComponentHealthConfig;
+    causalOrder: MonitorComponentHealthConfig;
+}
+export interface MonitorThrottleTierConfig {
+    maxEventsPerSecond: number;
+    batchSize: number;
+}
+export interface MonitorThrottleConfig {
+    open: MonitorThrottleTierConfig;
+    slow: MonitorThrottleTierConfig;
+    verySlow: MonitorThrottleTierConfig;
+    paused: MonitorThrottleTierConfig;
+    defaultTier: MonitorThrottleTier;
+}
+export interface MonitorReplayConfig {
+    healthConfirmationHeartbeats: number;
+    pauseLiveFlowDuringReplay: boolean;
+    retryBackoffMs: bigint;
+}
+export interface MonitorConfig {
+    reservoir: MonitorReservoirConfig;
+    transport: MonitorTransportConfig;
+    health: MonitorHealthConfig;
+    throttle: MonitorThrottleConfig;
+    replay: MonitorReplayConfig;
+    now?: () => bigint;
+}
+export declare function createDefaultMonitorConfig(): MonitorConfig;

package/.build/src/types/config.js

@@ -0,0 +1,54 @@
+export function createDefaultMonitorConfig() {
+    return {
+        reservoir: {
+            databasePath: ":memory:",
+            rollingBufferWindowMs: 4n * 60n * 60n * 1000n,
+            fullOutageMaxWindowMs: 6n * 60n * 60n * 1000n,
+            pruneIntervalMs: 60000n,
+        },
+        transport: {
+            heartbeatGraceMs: 15000n,
+            reconnectBurstWindowMs: 30000n,
+            sourceLabel: "@causal-order/transport",
+        },
+        health: {
+            transport: {
+                degradedAfterMs: 10000n,
+                offlineAfterMs: 30000n,
+            },
+            dedupe: {
+                degradedAfterMs: 10000n,
+                offlineAfterMs: 30000n,
+            },
+            causalOrder: {
+                degradedAfterMs: 10000n,
+                offlineAfterMs: 30000n,
+            },
+        },
+        throttle: {
+            open: {
+                maxEventsPerSecond: 5_000,
+                batchSize: 500,
+            },
+            slow: {
+                maxEventsPerSecond: 1_000,
+                batchSize: 200,
+            },
+            verySlow: {
+                maxEventsPerSecond: 250,
+                batchSize: 50,
+            },
+            paused: {
+                maxEventsPerSecond: 0,
+                batchSize: 0,
+            },
+            defaultTier: "open",
+        },
+        replay: {
+            healthConfirmationHeartbeats: 2,
+            pauseLiveFlowDuringReplay: true,
+            retryBackoffMs: 5000n,
+        },
+        now: () => BigInt(Date.now()),
+    };
+}

package/.build/src/types/events.d.ts

@@ -0,0 +1,51 @@
+export type MonitorComponent = "transport" | "dedupe" | "causal-order";
+export type MonitorHealthState = "online" | "degraded" | "offline";
+export type MonitorRoutingMode = "normal" | "dedupe_bypass_throttled" | "order_buffer_only" | "full_outage_buffer" | "replay_through_dedupe";
+export type MonitorThrottleTier = "open" | "slow" | "very_slow" | "paused";
+export type MonitorSourcePath = "transport_normalized_stream" | "deduped_observation";
+export type MonitorDeliveryMode = "normal" | "dedupe_bypass" | "order_buffer_only" | "full_outage_buffer" | "replay_through_dedupe";
+export type MonitorReplaySessionState = "idle" | "queued" | "running" | "completed" | "failed" | "aborted";
+export type MonitorReplayTargetPath = "dedupe_then_order";
+export type MonitorPeerState = "connected" | "disconnected" | "degraded";
+export type MonitorIngressAction = "accept" | "buffer_only" | "pause";
+export interface MonitorClock extends Record<string, unknown> {
+    physicalTimeMs: bigint;
+}
+export interface MonitorEventPayload {
+    traceId?: string | null;
+    entityId?: string | null;
+    service?: string;
+    operation?: string;
+    [key: string]: unknown;
+}
+export interface MonitorIngressEvent {
+    id: string;
+    nodeId: string;
+    clock: MonitorClock;
+    payload: MonitorEventPayload;
+    sequence?: bigint;
+    traceId?: string | null;
+    ingestedAt?: bigint;
+    [key: string]: unknown;
+}
+export interface MonitorPeerStateEvent {
+    peerId: string;
+    state: MonitorPeerState;
+    observedAt: bigint;
+    details?: Record<string, unknown>;
+}
+export interface MonitorHealthUpdate {
+    state: MonitorHealthState;
+    observedAt?: bigint;
+    reasonCode?: string | null;
+    details?: Record<string, unknown>;
+}
+export interface MonitorIngressDecision {
+    action: MonitorIngressAction;
+    routingMode: MonitorRoutingMode;
+    deliveryMode: MonitorDeliveryMode;
+    throttleTier: MonitorThrottleTier;
+    targetEventsPerSecond: number;
+    targetBatchSize: number;
+    reason: string;
+}

package/.build/src/types/events.js

@@ -0,0 +1 @@
+export {};