@lensmcp/protocol-types 1.25.8 → 1.25.10

package/lib/dashboard.d.ts

@@ -2518,7 +2518,8 @@ export interface DashAiRun {
             label: string;
             why: string;
         }>;
-        turns?: number;
+        turns?: number; /** Why its last turn ended, the provider's word (`end_turn`, `max_tokens`). */
+        stopReason?: string;
     };
     /**
      * How the frontier model worked, turn by turn, as it streamed: its reasoning (summarized), what it wrote, each tool it

package/lib/event.d.ts

@@ -22,6 +22,7 @@ export declare const EventSourceSchema: z.ZodEnum<{
     external: "external";
     ai: "ai";
     lens: "lens";
+    custom: "custom";
 }>;
 export type EventSource = z.infer<typeof EventSourceSchema>;
 export declare const EventCategorySchema: z.ZodEnum<{
@@ -81,6 +82,7 @@ export declare const BaseEventSchema: z.ZodObject<{
         external: "external";
         ai: "ai";
         lens: "lens";
+        custom: "custom";
     }>;
     category: z.ZodEnum<{
         db: "db";

package/lib/event.js

@@ -1 +1 @@
-"use strict";import{z as e}from"zod";import{SourceLocationSchema as t}from"./source-location.js";import{TraceContextSchema as r}from"./context.js";export const EventSourceSchema=e.enum(["nx","vite","typescript","eslint","rollup","client-runtime","chrome","react","valtio","nestjs","nextjs","db","redis","queue","memory","visual","perf","security","gateway","external","ai","lens"]),EventCategorySchema=e.enum(["build","lint","typecheck","test","runtime","render","visual","trace","state","network","backend","db","memory","performance","security","deps","cluster","ai","agent"]),SeveritySchema=e.enum(["debug","info","warning","error","fatal"]),BaseEventSchema=e.object({id:e.string(),sessionId:e.string(),timestamp:e.number().int().nonnegative(),source:EventSourceSchema,category:EventCategorySchema,severity:SeveritySchema,context:r,fingerprint:e.string(),title:e.string(),message:e.string().optional(),location:t.optional(),relatedFiles:e.array(e.string()).optional(),relatedUrls:e.array(e.string()).optional(),raw:e.unknown().optional()});
+"use strict";import{z as e}from"zod";import{SourceLocationSchema as t}from"./source-location.js";import{TraceContextSchema as r}from"./context.js";export const EventSourceSchema=e.enum(["nx","vite","typescript","eslint","rollup","client-runtime","chrome","react","valtio","nestjs","nextjs","db","redis","queue","memory","visual","perf","security","gateway","external","ai","lens","custom"]),EventCategorySchema=e.enum(["build","lint","typecheck","test","runtime","render","visual","trace","state","network","backend","db","memory","performance","security","deps","cluster","ai","agent"]),SeveritySchema=e.enum(["debug","info","warning","error","fatal"]),BaseEventSchema=e.object({id:e.string(),sessionId:e.string(),timestamp:e.number().int().nonnegative(),source:EventSourceSchema,category:EventCategorySchema,severity:SeveritySchema,context:r,fingerprint:e.string(),title:e.string(),message:e.string().optional(),location:t.optional(),relatedFiles:e.array(e.string()).optional(),relatedUrls:e.array(e.string()).optional(),raw:e.unknown().optional()});

package/lib/sources.d.ts

@@ -1,5 +1,5 @@
 /**
- * CUSTOM SOURCES (issues/open/foodguard-81) — an application REPORTS what the lens cannot observe, as one of a closed
+ * CUSTOM SOURCES (issues/closed/foodguard-81) — an application REPORTS what the lens cannot observe, as one of a closed
  * set of typed kinds the lens knows how to draw, threshold and explain to an agent: `queue` · `loop` · `store` ·
  * `traffic`. Phase 1 reads `queue` only — work a service keeps waiting in its OWN storage (an outbox table), which no
  * event stream can show: FoodGuard's lens showed its BullMQ queues nearly empty while 6,389 outbox rows waited.
@@ -19,26 +19,103 @@
  *  3. The READ — `apps/agent` folds them into `process://sources` ({@link SourcesReport}); the `observe.sources` and
  *     `source.get` tools, the status signal and the dashboard read that.
  *
+ * Phase 2 adds:
+ *  - the `loop` kind — a background loop, scheduler or sweep answering `lensmcp.loop/v1` ({@link LoopSnapshotRaw});
+ *    `feeds` links it to the queue source it drains;
+ *  - PUSHED events — `lensEmitCustom` (`@lensmcp/node-instrumentation`) writes a `source: 'custom'` event
+ *    ({@link SourceEventRaw}) with the flow context of the request or job it ran in, so an outbox row's `enqueued` shows
+ *    in the flow of the answer that wrote it;
+ *  - reports ON CHANGE: a poll whose snapshot did not change carries `same` ({@link SourceSameRaw}) instead of the whole
+ *    snapshot, and a full one goes at least every {@link SOURCE_FULL_REPORT_MS};
+ *  - the lens's history of each source, and the findings it needs: `queue/stalled`, `loop/overdue`, `loop/failing`,
+ *    `loop/idle-while-fed`.
+ *
+ * Phase 3 adds the last two kinds:
+ *  - `store` — a storage backend the taps do not model (document storage on disk or in a bucket, a chunk store):
+ *    `lensmcp.store/v1` ({@link StoreSnapshotRaw}) says how many objects and bytes it holds against its quota, and its
+ *    window's writes, deletes and errors. Findings `store/near-quota`, `store/errors`, `store/orphans` (it grows and
+ *    nothing is deleted);
+ *  - `traffic` — messages over a channel the taps do not classify (a partner's API answering 429s, a webhook, a custom
+ *    transport): `lensmcp.traffic/v1` ({@link TrafficSnapshotRaw}) per channel — messages, failures, rate-limited,
+ *    p95 — or, with no `path`, PUSH-ONLY: the lens counts what the app pushes (`inbound` / `outbound`) over the last
+ *    {@link TRAFFIC_PUSH_WINDOW_MS}. Findings `traffic/failures`, `traffic/latency`, `traffic/rate-limited`.
+ *
  * Everything here is REPORTED by the app, never measured by the lens: every read carries `provenance: 'reported'`.
  * Additive only.
  */
 /** The closed set of source kinds. */
 export declare const SOURCE_KINDS: readonly ["queue", "loop", "store", "traffic"];
 export type SourceKind = (typeof SOURCE_KINDS)[number];
-/** The kinds this release reads; a declared kind outside it is said, not polled. */
-export declare const SOURCE_KINDS_READ: readonly ["queue"];
+/** The kinds this release reads — all of them since phase 3; a kind outside the set is said, not polled. */
+export declare const SOURCE_KINDS_READ: readonly ["queue", "loop", "store", "traffic"];
 export type SourceKindRead = (typeof SOURCE_KINDS_READ)[number];
 /** Every snapshot's schema: `lensmcp.<kind>/v1`. */
 export declare const sourceWireSchema: (kind: SourceKind) => string;
 export declare const QUEUE_WIRE_SCHEMA = "lensmcp.queue/v1";
+export declare const LOOP_WIRE_SCHEMA = "lensmcp.loop/v1";
+export declare const STORE_WIRE_SCHEMA = "lensmcp.store/v1";
+export declare const TRAFFIC_WIRE_SCHEMA = "lensmcp.traffic/v1";
+/** Where each kind's last good snapshot rides on a `source-poll` raw — never another kind's field. */
+export declare const SOURCE_SNAPSHOT_FIELD: {
+    readonly queue: "snapshot";
+    readonly loop: "loop";
+    readonly store: "store";
+    readonly traffic: "traffic";
+};
 /** The resource the lens folds the polls into. */
 export declare const URI_SOURCES = "process://sources";
 /** Said on every read of a source: the app's claim, not the lens's measurement. */
 export declare const SOURCE_PROVENANCE: "reported";
-/** The finding's rule id: a queue group whose oldest pending item has waited longer than `thresholds.oldestWaitMin`. */
+/** A queue group whose oldest pending item has waited longer than `thresholds.oldestWaitMin`. */
 export declare const QUEUE_OLDEST_WAIT_RULE = "queue/oldest-wait";
-export declare const SOURCE_EVENT_KINDS: readonly ["source-poll", "source-declaration"];
+/** A queue group with pending work that has not moved for `thresholds.stalledMin` (nothing taken, nothing finished). */
+export declare const QUEUE_STALLED_RULE = "queue/stalled";
+/** A loop whose next run is late by more than {@link LOOP_OVERDUE_INTERVALS} of its intervals. */
+export declare const LOOP_OVERDUE_RULE = "loop/overdue";
+/** A loop whose last {@link LOOP_FAILING_RUNS} runs all failed. */
+export declare const LOOP_FAILING_RULE = "loop/failing";
+/** A loop that runs and takes nothing, for `thresholds.idleMin`, while the queue it `feeds` has work. */
+export declare const LOOP_IDLE_RULE = "loop/idle-while-fed";
+/** A store whose bytes are at or over `thresholds.quotaPct` of its quota. */
+export declare const STORE_QUOTA_RULE = "store/near-quota";
+/** A store with errors in its window — over `thresholds.errorRatePct` of its operations when it says how many. */
+export declare const STORE_ERRORS_RULE = "store/errors";
+/** A store that has grown for `thresholds.orphanMin` and deleted nothing — what nothing cleans up. */
+export declare const STORE_ORPHANS_RULE = "store/orphans";
+/** A channel whose failures are over `thresholds.failurePct` of at least {@link TRAFFIC_MIN_MESSAGES} messages. */
+export declare const TRAFFIC_FAILURES_RULE = "traffic/failures";
+/** A channel whose p95 is over `thresholds.p95Ms`. */
+export declare const TRAFFIC_LATENCY_RULE = "traffic/latency";
+/** A channel whose counterpart answered «too many requests» `thresholds.rateLimited` times or more in the window. */
+export declare const TRAFFIC_RATE_LIMITED_RULE = "traffic/rate-limited";
+export declare const SOURCE_RULES: readonly ["queue/oldest-wait", "queue/stalled", "loop/overdue", "loop/failing", "loop/idle-while-fed", "store/near-quota", "store/errors", "store/orphans", "traffic/failures", "traffic/latency", "traffic/rate-limited"];
+export type SourceRule = (typeof SOURCE_RULES)[number];
+export declare const SOURCE_EVENT_KINDS: readonly ["source-poll", "source-declaration", "source-event"];
 export type SourceEventKind = (typeof SOURCE_EVENT_KINDS)[number];
+/** A pushed event's `source` — the app's own words, never a tap's. */
+export declare const CUSTOM_EVENT_SOURCE: "custom";
+/** What a queue source's app may push: an item written, taken, finished, failed, or set aside. */
+export declare const QUEUE_EVENTS: readonly ["enqueued", "admitted", "completed", "failed", "parked"];
+export type QueueEventName = (typeof QUEUE_EVENTS)[number];
+/** What a loop source's app may push: a run began, a run ended. */
+export declare const LOOP_EVENTS: readonly ["run-start", "run-end"];
+export type LoopEventName = (typeof LOOP_EVENTS)[number];
+/** How a loop's run ended: it worked, it failed, or it chose not to (a gate held it). */
+export declare const LOOP_OUTCOMES: readonly ["ok", "failed", "skipped"];
+export type LoopOutcome = (typeof LOOP_OUTCOMES)[number];
+/** What a store source's app may push: an object written, deleted, or an operation that failed. */
+export declare const STORE_EVENTS: readonly ["write", "delete", "error"];
+export type StoreEventName = (typeof STORE_EVENTS)[number];
+/** What a traffic source's app may push: a message that came in, a message that went out. */
+export declare const TRAFFIC_EVENTS: readonly ["inbound", "outbound"];
+export type TrafficEventName = (typeof TRAFFIC_EVENTS)[number];
+/** How a message went: answered, failed, or refused as too many (an HTTP 429, a quota). */
+export declare const TRAFFIC_OUTCOMES: readonly ["ok", "failed", "rate-limited"];
+export type TrafficOutcome = (typeof TRAFFIC_OUTCOMES)[number];
+/** The events each kind may push. */
+export declare const SOURCE_PUSH_EVENTS: Readonly<Record<SourceKindRead, readonly string[]>>;
+/** The outcomes each kind's pushed events may say (a queue's and a store's say none). */
+export declare const SOURCE_PUSH_OUTCOMES: Readonly<Record<SourceKindRead, readonly string[]>>;
 /** What ONE poll found. */
 export declare const SOURCE_POLL_STATES: readonly ["current", "unreachable", "refused", "malformed", "not-running"];
 export type SourcePollState = (typeof SOURCE_POLL_STATES)[number];
@@ -52,6 +129,39 @@ export type SourceState = (typeof SOURCE_STATES)[number];
 export declare const SOURCE_DEFAULT_INTERVAL_SEC = 10;
 export declare const SOURCE_MIN_INTERVAL_SEC = 2;
 export declare const QUEUE_DEFAULT_OLDEST_WAIT_MIN = 10;
+export declare const QUEUE_DEFAULT_STALLED_MIN = 15;
+export declare const LOOP_DEFAULT_IDLE_MIN = 10;
+/** `loop/overdue`: its next run is late by more than this many of its own intervals. */
+export declare const LOOP_OVERDUE_INTERVALS = 2;
+/** `loop/failing`: this many runs in a row failed. */
+export declare const LOOP_FAILING_RUNS = 3;
+/**
+ * A poll whose snapshot did not change since the one last sent in full carries {@link SourceSameRaw} instead — but a
+ * full snapshot goes at least this often, so a lens that starts later (its replay is a few MB of the bus) has one
+ * within a minute. Before this, every poll carried the whole snapshot: ~2 MB an hour at FoodGuard's size, ~60 MB at
+ * the 500-group cap.
+ */
+export declare const SOURCE_FULL_REPORT_MS = 60000;
+/** History points the lens keeps per source (in memory; a lens restart starts it again). */
+export declare const SOURCE_HISTORY_POINTS = 60;
+/** A loop's runs the lens keeps. */
+export declare const SOURCE_RUNS_KEPT = 30;
+/** Pushed events the lens keeps per source. */
+export declare const SOURCE_PUSHED_KEPT = 20;
+export declare const STORE_DEFAULT_QUOTA_PCT = 90;
+export declare const STORE_DEFAULT_ERROR_RATE_PCT = 5;
+/** `store/orphans`: growing this long with nothing deleted. An append-only store by design raises it (at most 10080). */
+export declare const STORE_DEFAULT_ORPHAN_MIN = 60;
+export declare const TRAFFIC_DEFAULT_FAILURE_PCT = 5;
+export declare const TRAFFIC_DEFAULT_P95_MS = 2000;
+export declare const TRAFFIC_DEFAULT_RATE_LIMITED = 1;
+/** `traffic/failures` is judged on at least this many messages in the window — 1 failure of 2 is not a rate. */
+export declare const TRAFFIC_MIN_MESSAGES = 10;
+/** A push-only traffic source: the lens counts what was pushed over this window. */
+export declare const TRAFFIC_PUSH_WINDOW_MS: number;
+/** A push-only traffic source: channels and events per channel the lens keeps to count from. */
+export declare const TRAFFIC_PUSH_CHANNELS = 50;
+export declare const TRAFFIC_PUSH_EVENTS_PER_CHANNEL = 1000;
 /** A snapshot holds at most this many groups; a producer with more caps it and says `truncated: { groups }`. */
 export declare const SOURCE_MAX_GROUPS = 500;
 export declare const SOURCE_MAX_BYTES: number;
@@ -60,18 +170,55 @@ export declare const SOURCE_STALE_PERIODS = 3;
 export declare const SOURCE_STALE_MIN_MS = 30000;
 /** When a source's newest report stops being trusted. */
 export declare function sourceStaleAfterMs(reportEveryMs: number): number;
-/** A queue source's thresholds. `stalledMin` is accepted now and judged once the lens keeps a history (phase 2). */
+/** A queue source's thresholds, in minutes. The gateway fills both defaults; a 1.25.8 gateway sent no `stalledMin`. */
 export interface QueueThresholds {
     oldestWaitMin: number;
     stalledMin?: number;
 }
+/** A loop source's thresholds, in minutes (the gateway fills the default). */
+export interface LoopThresholds {
+    idleMin?: number;
+}
+/** A store source's thresholds (the gateway fills the defaults). */
+export interface StoreThresholds {
+    /** Percent of `quotaBytes` (0–100). */
+    quotaPct?: number;
+    /** Percent of the window's operations (0–100). */
+    errorRatePct?: number;
+    /** Minutes. */
+    orphanMin?: number;
+}
+/** A traffic source's thresholds (the gateway fills the defaults). */
+export interface TrafficThresholds {
+    /** Percent of a channel's messages in the window (0–100). */
+    failurePct?: number;
+    /** Milliseconds. */
+    p95Ms?: number;
+    /** «Too many requests» answers in the window, at least 1. */
+    rateLimited?: number;
+}
+/**
+ * A source's thresholds, any kind's: a queue has `oldestWaitMin` (always) and `stalledMin`; a loop `idleMin`; a store
+ * `quotaPct`, `errorRatePct`, `orphanMin`; a traffic source `failurePct`, `p95Ms`, `rateLimited`.
+ */
+export interface SourceThresholds extends StoreThresholds, TrafficThresholds {
+    oldestWaitMin?: number;
+    stalledMin?: number;
+    idleMin?: number;
+}
 /** One declared source, as the gateway polls it. */
 export interface SourceDeclRaw {
     sourceKind: SourceKindRead;
     name: string;
-    path: string;
+    /**
+     * Absent only on a PUSH-ONLY loop or traffic source: never polled; the lens reads what the app pushes. A push-only
+     * loop's `intervalSec` is the loop's OWN period (the lens judges «overdue» by it); a polled one's is the poll's.
+     */
+    path?: string;
     intervalSec: number;
-    thresholds: QueueThresholds;
+    thresholds: SourceThresholds;
+    /** A loop: the NAME of the queue source on the same service that it drains — what `loop/idle-while-fed` reads. */
+    feeds?: string;
 }
 /** One group of a queue snapshot, as the bus carries it. */
 export interface QueueGroupRaw {
@@ -106,6 +253,114 @@ export interface QueueSnapshotRaw {
     truncated?: {
         groups: number;
     };
+    /** Names the snapshot's content (not its times): a later poll that read the same says so with {@link SourceSameRaw}. */
+    digest?: string;
+}
+/**
+ * A loop snapshot that parsed — what a background loop, scheduler or sweep says of itself. The wire
+ * (`lensmcp.loop/v1`) is the same fields plus `schema`, without `receivedAt`/`digest`; only `at`, `intervalSec` and
+ * `lastRunAt` are required.
+ */
+export interface LoopSnapshotRaw {
+    /** When the SERVICE measured it (ISO). */
+    at: string;
+    /** When the gateway received it (epoch ms). */
+    receivedAt: number;
+    digest?: string;
+    /** The loop's own period, in seconds (not the poll's). */
+    intervalSec: number;
+    /** When its last run began (ISO); `null`: it has not run since the service started. */
+    lastRunAt: string | null;
+    lastDurationMs?: number;
+    lastOutcome?: LoopOutcome;
+    /** Items its last run took. */
+    lastItems?: number;
+    /** When it will run next (ISO), if it knows. */
+    nextRunAt?: string | null;
+    /** Over the service's own window of `windowSec`. */
+    runsInWindow?: number;
+    itemsInWindow?: number;
+    failuresInWindow?: number;
+    windowSec?: number;
+    /** The last failed run's error, at most 500 characters. */
+    lastError?: string;
+}
+/** One group of a store — a bucket, a tenant's folder — as the bus carries it (the wire's `key` travels as `group`). */
+export interface StoreGroupRaw {
+    group: string;
+    labels?: Record<string, string>;
+    objects: number;
+    bytes: number;
+}
+/**
+ * A store snapshot that parsed — what a storage backend the taps do not model says of itself. The wire
+ * (`lensmcp.store/v1`) is the same fields plus `schema`, without `receivedAt`/`digest`, its groups keyed `key`; only
+ * `at`, `objects` and `bytes` are required.
+ */
+export interface StoreSnapshotRaw {
+    at: string;
+    receivedAt: number;
+    digest?: string;
+    objects: number;
+    bytes: number;
+    /** What it may hold; absent or `null`: no quota it knows of. */
+    quotaBytes?: number | null;
+    /** Operations of every kind over the service's window of `windowSec` — what `errorsInWindow` is a rate of. */
+    opsInWindow?: number;
+    writesInWindow?: number;
+    deletesInWindow?: number;
+    errorsInWindow?: number;
+    windowSec?: number;
+    lastWriteAt?: string | null;
+    /** The last failed operation's error, at most 500 characters. */
+    lastError?: string;
+    /** At most {@link SOURCE_MAX_GROUPS}, the largest first. */
+    groups?: StoreGroupRaw[];
+    truncated?: {
+        groups: number;
+    };
+}
+/** One channel of a traffic source, as the bus carries it (the wire's `key` travels as `channel`). */
+export interface TrafficChannelRaw {
+    channel: string;
+    labels?: Record<string, string>;
+    direction?: 'inbound' | 'outbound';
+    /** Who is at the other end — a partner, a host, a queue — at most 200 characters. */
+    counterpart?: string;
+    /** Over the service's window of `windowSec`. */
+    messagesInWindow?: number;
+    failuresInWindow?: number;
+    /** Answered «too many requests» (an HTTP 429, a quota) — counted apart from `failuresInWindow`. */
+    rateLimitedInWindow?: number;
+    p95Ms?: number;
+    lastAt?: string | null;
+    lastError?: string;
+}
+/**
+ * A traffic snapshot that parsed — messages over channels the taps do not classify. The wire (`lensmcp.traffic/v1`) is
+ * the same plus `schema`, each channel keyed `key`; only `at` and `channels` are required.
+ */
+export interface TrafficSnapshotRaw {
+    at: string;
+    receivedAt: number;
+    digest?: string;
+    windowSec?: number;
+    /** At most {@link SOURCE_MAX_GROUPS}. */
+    channels: TrafficChannelRaw[];
+    truncated?: {
+        channels: number;
+    };
+}
+/**
+ * In place of the snapshot, on a poll that read what an earlier report carried in full (the same `digest`): the lens
+ * takes the one it holds, measured again at `at` and received at `receivedAt`. On a poll that did not read (`unreachable`
+ * …) `at`/`receivedAt` are the held snapshot's own. A lens that holds no snapshot of that digest (it started after the
+ * full report) says the source is not read yet — never «nothing pending» — until the next full report.
+ */
+export interface SourceSameRaw {
+    digest: string;
+    at: string;
+    receivedAt: number;
 }
 /** One poll of one declared source (`raw.kind: 'source-poll'`). */
 export interface SourcePollRaw extends SourceDeclRaw {
@@ -124,12 +379,62 @@ export interface SourcePollRaw extends SourceDeclRaw {
     reportEveryMs: number;
     /** Polls in a row that failed (`unreachable`/`refused`/`malformed`) — the gateway backs off while it grows. */
     failures?: number;
-    /** The LAST GOOD snapshot: this poll's when `current`, else the one before (kept, with its age), if any. */
+    /**
+     * A QUEUE source's LAST GOOD snapshot: this poll's when `current`, else the one before (kept, with its age), if any.
+     * Absent with `same` when it is the one an earlier report carried.
+     */
     snapshot?: QueueSnapshotRaw;
+    /** A LOOP source's last good snapshot — the same rules as `snapshot`. */
+    loop?: LoopSnapshotRaw;
+    /** A STORE source's. */
+    store?: StoreSnapshotRaw;
+    /** A TRAFFIC source's (a push-only one is never polled). */
+    traffic?: TrafficSnapshotRaw;
+    /** In place of the kind's snapshot ({@link SOURCE_SNAPSHOT_FIELD}): unchanged since the report that carried it in full. */
+    same?: SourceSameRaw;
     /** The owning workspace (stamped by the gateway on every service event). */
     wsKey?: string;
     floodSuppressed?: number;
 }
+/**
+ * One event an app PUSHED about a source (`source: 'custom'`, `category: 'backend'`, `raw.kind: 'source-event'`),
+ * written by `lensEmitCustom` in the app's own process with the flow context it ran in (`context.flowId`/`requestId`/
+ * `runId`) — so it joins that request's or job's flow like any tapped event. Bounded: one flood bucket per (service,
+ * kind, name, event) — and per channel for traffic — so a burst of `enqueued` never starves `completed`.
+ */
+export interface SourceEventRaw {
+    kind: 'source-event';
+    provenance: typeof SOURCE_PROVENANCE;
+    /** The service (its Nx project) — what the source's declaration is under. */
+    project: string;
+    sourceKind: SourceKindRead;
+    /** The declared source's `name`. */
+    name: string;
+    /** One of the kind's {@link SOURCE_PUSH_EVENTS}. */
+    event: string;
+    /** The item's own id (an outbox row), at most 200 characters. */
+    item?: string;
+    /** The snapshot group it belongs to (the wire's group `key`), at most 200 characters. */
+    group?: string;
+    /** A loop's `run-end`: items the run took. */
+    items?: number;
+    durationMs?: number;
+    /** A loop's `run-end` ({@link LOOP_OUTCOMES}); a traffic message's ({@link TRAFFIC_OUTCOMES}). */
+    outcome?: LoopOutcome | TrafficOutcome;
+    /** A store's: the object — an id or a hash, never a name that holds personal data — at most 200 characters. */
+    object?: string;
+    /** A store's `write`; a traffic message's size. */
+    bytes?: number;
+    /** A traffic message's channel (the snapshot channel's key), at most 200 characters. */
+    channel?: string;
+    /** A traffic message's other end, at most 200 characters. */
+    counterpart?: string;
+    /** A traffic message's correlation id (what joins an inbound to the outbound it caused), at most 200 characters. */
+    correlation?: string;
+    /** A `failed` item or a failed run: why, at most 500 characters. */
+    error?: string;
+    floodSuppressed?: number;
+}
 /** A service's `cluster.sources`, as the gateway read it (`raw.kind: 'source-declaration'`). */
 export interface SourceDeclarationRaw {
     kind: 'source-declaration';
@@ -142,6 +447,8 @@ export interface SourceDeclarationRaw {
 }
 /** A `source-poll` event's `raw`, checked just enough to be read safely (telemetry is only partly trusted). */
 export declare function asSourcePollRaw(raw: unknown): SourcePollRaw | undefined;
+/** A `source-event` event's `raw` (pushed by an app), checked just enough to be read safely. */
+export declare function asSourceEventRaw(raw: unknown): SourceEventRaw | undefined;
 /** A `source-declaration` event's `raw`, checked just enough to be read safely. */
 export declare function asSourceDeclarationRaw(raw: unknown): SourceDeclarationRaw | undefined;
 /** One queue group, as the lens shows it. */
@@ -150,6 +457,14 @@ export interface QueueGroupView extends QueueGroupRaw {
     oldestWaitMs?: number;
     /** That wait is longer than the source's `thresholds.oldestWaitMin`. */
     overThreshold: boolean;
+    /**
+     * How long its pending work has not moved, as far as the lens has watched it (since this lens started, or since the
+     * work last moved): nothing taken (`pending` did not fall, `oldestPendingAt` did not advance), nothing finished
+     * (`completedInWindow` 0), no `admitted`/`completed` pushed. Absent when nothing is pending or it moved just now.
+     */
+    stillMs?: number;
+    /** `stillMs` is at least the source's `thresholds.stalledMin`. */
+    stalled: boolean;
 }
 /** A queue source's headline numbers. */
 export interface QueueHeadline extends QueueTotals {
@@ -157,6 +472,95 @@ export interface QueueHeadline extends QueueTotals {
     oldestWaitMs?: number;
     /** Groups whose oldest wait is over the threshold. */
     overThreshold: number;
+    /** Groups stalled. */
+    stalled: number;
+}
+/** One point of a queue source's history: what one `current` read said. */
+export interface QueueHistoryPoint {
+    /** When the gateway received it (epoch ms). */
+    t: number;
+    pending: number;
+    inFlight: number;
+    failed: number;
+    oldestWaitMs?: number;
+}
+/** One run of a loop: seen in a snapshot (its `lastRunAt` moved) or pushed (`run-end`). */
+export interface LoopRunView {
+    /** When it began (epoch ms) — `lastRunAt`, or the pushed `run-end`'s time less its duration. */
+    at: number;
+    outcome?: LoopOutcome;
+    items?: number;
+    durationMs?: number;
+    error?: string;
+    via: 'snapshot' | 'pushed';
+}
+/** A loop source's headline, from its last good snapshot and the runs the lens saw. */
+export interface LoopView {
+    intervalSec: number;
+    lastRunAt: string | null;
+    lastDurationMs?: number;
+    lastOutcome?: LoopOutcome;
+    lastItems?: number;
+    nextRunAt?: string | null;
+    runsInWindow?: number;
+    itemsInWindow?: number;
+    failuresInWindow?: number;
+    windowSec?: number;
+    lastError?: string;
+    /** How late its next run was when the service measured it — past `nextRunAt` (or `lastRunAt` + its interval). */
+    lateMs?: number;
+    /** Late by more than {@link LOOP_OVERDUE_INTERVALS} of its intervals. */
+    overdue: boolean;
+    /** Runs in a row that failed, the newest back. */
+    failingRuns: number;
+    /** Since when (epoch ms) it has run and taken nothing while the queue it feeds had work — when it does now. */
+    idleSince?: number;
+    /** The queue source it `feeds`, as read now (absent: it declares none, or none of that name). */
+    fed?: {
+        name: string;
+        state: SourceState;
+        pending?: number;
+    };
+    /**
+     * PUSH-ONLY (declared with no route): built from the runs the app pushed (`run-start` / `run-end`), judged on the
+     * lens's own clock — `lateMs` is how long after its period its next run is now, with `intervalSec` its declared period.
+     */
+    pushOnly?: boolean;
+    /** Push-only: a run began (`run-start`) and has not ended — since when (epoch ms). */
+    runningSince?: number;
+}
+/** One event an app pushed about a source. */
+export interface SourcePushedEvent {
+    at: number;
+    event: string;
+    item?: string;
+    group?: string;
+    items?: number;
+    durationMs?: number;
+    outcome?: LoopOutcome | TrafficOutcome;
+    /** A store's object (an id or a hash). */
+    object?: string;
+    bytes?: number;
+    /** A traffic message's channel, other end and correlation id. */
+    channel?: string;
+    counterpart?: string;
+    correlation?: string;
+    error?: string;
+    /** The flow it ran in — open it with flow.get. */
+    flowId?: string;
+    requestId?: string;
+}
+/** What an app pushed about one source since this lens started. */
+export interface SourcePushedView {
+    /** Per event name. */
+    counts: Record<string, number>;
+    /** When the first one reached this lens (epoch ms). */
+    since: number;
+    lastAt: number;
+    /** The newest first, at most {@link SOURCE_PUSHED_KEPT}. */
+    recent: SourcePushedEvent[];
+    /** Events the app's flood guard held back (they are in no count). */
+    suppressed?: number;
 }
 /** One declared source, as the lens shows it. */
 export interface SourceView extends SourceDeclRaw {
@@ -173,25 +577,121 @@ export interface SourceView extends SourceDeclRaw {
     ageMs?: number;
     /** When the service measured the last good snapshot (its `at`). */
     snapshotAt?: string;
+    /** A queue's. */
     headline?: QueueHeadline;
-    /** The oldest-waiting first. Empty with `state: 'current'` is a real «nothing pending». */
+    /** A queue's, the oldest-waiting first. Empty with `state: 'current'` and a headline is a real «nothing pending». */
     groups: QueueGroupView[];
     truncated?: {
         groups: number;
     };
+    /** A queue's `current` reads, oldest first, at most {@link SOURCE_HISTORY_POINTS}. */
+    history?: QueueHistoryPoint[];
+    /** A loop's, from its last good snapshot. */
+    loop?: LoopView;
+    /** A loop's runs, the newest first, at most {@link SOURCE_RUNS_KEPT}. */
+    runs?: LoopRunView[];
+    /** A store's, from its last good snapshot. */
+    store?: StoreView;
+    /** A store's `current` reads, oldest first, at most {@link SOURCE_HISTORY_POINTS}. */
+    storeHistory?: StoreHistoryPoint[];
+    /** A traffic source's: from its last good snapshot, or — push-only — from what the app pushed in the window. */
+    traffic?: TrafficView;
+    /** What the app pushed about it (`lensEmitCustom`), when it pushed anything. */
+    pushed?: SourcePushedView;
+}
+/** A store's headline, from its last good snapshot and the reads the lens watched. */
+export interface StoreView {
+    objects: number;
+    bytes: number;
+    quotaBytes?: number | null;
+    /** `bytes` as a percent of `quotaBytes` (one decimal). */
+    usedPct?: number;
+    /** `usedPct` is at or over `thresholds.quotaPct`. */
+    nearQuota: boolean;
+    opsInWindow?: number;
+    writesInWindow?: number;
+    deletesInWindow?: number;
+    errorsInWindow?: number;
+    /** `errorsInWindow` as a percent of `opsInWindow`, when it says both. */
+    errorRatePct?: number;
+    windowSec?: number;
+    lastWriteAt?: string | null;
+    lastError?: string;
+    /**
+     * Since when (epoch ms) it has grown with nothing deleted, as the lens watched it: its objects rose, never fell, no
+     * `deletesInWindow`, no pushed `delete`. Absent when it deleted lately, did not grow, or was not watched long enough.
+     */
+    growingSince?: number;
+    /** Its objects when that spell began. */
+    growingFrom?: number;
+    /** The largest first. */
+    groups?: StoreGroupRaw[];
+    truncated?: {
+        groups: number;
+    };
+}
+/** One point of a store's history: what one `current` read said. */
+export interface StoreHistoryPoint {
+    t: number;
+    objects: number;
+    bytes: number;
+}
+/** One channel of a traffic source, as the lens shows it. */
+export interface TrafficChannelView extends TrafficChannelRaw {
+    /** `failuresInWindow` as a percent of `messagesInWindow` (one decimal). */
+    failurePct?: number;
+    /** Over `thresholds.failurePct`, on at least {@link TRAFFIC_MIN_MESSAGES} messages. */
+    overFailure: boolean;
+    /** `p95Ms` over `thresholds.p95Ms`. */
+    overLatency: boolean;
+    /** `rateLimitedInWindow` at or over `thresholds.rateLimited`. */
+    rateLimited: boolean;
+}
+/** A traffic source's headline. */
+export interface TrafficView {
+    /** Counted by the lens from the app's pushed events (no route declared), not answered by the service. */
+    pushOnly: boolean;
+    /** The window its counts are over, in seconds — the service's, or {@link TRAFFIC_PUSH_WINDOW_MS} push-only. */
+    windowSec?: number;
+    /** The channel with the most messages first. */
+    channels: TrafficChannelView[];
+    truncated?: {
+        channels: number;
+    };
+    totals: {
+        channels: number;
+        messages: number;
+        failures: number;
+        rateLimited: number;
+    };
+    /** Push-only: events the app's flood guard held back in the window — every count is then a floor. */
+    heldBack?: number;
 }
-/** A queue group whose oldest pending item has waited longer than its source allows. */
+/**
+ * Something a source's numbers say is wrong — from what was read NOW (`current`) only: anything older is not known to
+ * be true. Which fields are set depends on the rule.
+ */
 export interface SourceFinding {
-    rule: typeof QUEUE_OLDEST_WAIT_RULE;
+    rule: SourceRule;
     provenance: typeof SOURCE_PROVENANCE;
     project: string;
     name: string;
     sourceKind: SourceKindRead;
-    group: string;
+    /** A queue rule's group. */
+    group?: string;
+    /** A traffic rule's channel. */
+    channel?: string;
     labels?: Record<string, string>;
-    pending: number;
-    oldestWaitMs: number;
-    thresholdMin: number;
+    pending?: number;
+    /** `queue/oldest-wait`. */
+    oldestWaitMs?: number;
+    /** How long it has held: the stall, the idle spell, how late the run is, how long the runs have failed, the growth. */
+    forMs?: number;
+    /** The threshold it is over, in minutes (`loop/overdue` and `loop/failing` have none). */
+    thresholdMin?: number;
+    /** A store or traffic rule's measure — a percent, milliseconds or a count, as its title says — and its threshold. */
+    value?: number;
+    threshold?: number;
     title: string;
     fix: string[];
     verify: string;
@@ -215,6 +715,14 @@ export interface SourcesReport {
         project: string;
         problem: string;
     }>;
+    /** Sources an app pushes events about that no `cluster.sources` entry of that service declares — read nowhere. */
+    undeclared?: Array<{
+        project: string;
+        sourceKind: SourceKindRead;
+        name: string;
+        events: number;
+        lastAt: number;
+    }>;
     counts: Record<SourceState, number>;
     /** Over the `current` queue snapshots only. */
     totals: {

package/lib/sources.js

@@ -1 +1 @@
-"use strict";var E=Object.defineProperty;var n=(r,t)=>E(r,"name",{value:t,configurable:!0});var f=Object.defineProperty,e=n((r,t)=>f(r,"name",{value:t,configurable:!0}),"n");export const SOURCE_KINDS=["queue","loop","store","traffic"],SOURCE_KINDS_READ=["queue"],sourceWireSchema=e(r=>`lensmcp.${r}/v1`,"sourceWireSchema"),QUEUE_WIRE_SCHEMA="lensmcp.queue/v1",URI_SOURCES="process://sources",SOURCE_PROVENANCE="reported",QUEUE_OLDEST_WAIT_RULE="queue/oldest-wait",SOURCE_EVENT_KINDS=["source-poll","source-declaration"],SOURCE_POLL_STATES=["current","unreachable","refused","malformed","not-running"],SOURCE_STATES=[...SOURCE_POLL_STATES,"stale","never-polled"],SOURCE_DEFAULT_INTERVAL_SEC=10,SOURCE_MIN_INTERVAL_SEC=2,QUEUE_DEFAULT_OLDEST_WAIT_MIN=10,SOURCE_MAX_GROUPS=500,SOURCE_MAX_BYTES=256*1024,SOURCE_STALE_PERIODS=3,SOURCE_STALE_MIN_MS=3e4;export function sourceStaleAfterMs(r){return Math.max(SOURCE_STALE_MIN_MS,SOURCE_STALE_PERIODS*Math.max(0,r))}n(sourceStaleAfterMs,"sourceStaleAfterMs"),e(sourceStaleAfterMs,"sourceStaleAfterMs");const o=e(r=>typeof r=="object"&&r!==null&&!Array.isArray(r),"isObj"),i=e(r=>typeof r=="number"&&Number.isInteger(r)&&r>=0,"isCount"),c=e(r=>typeof r=="number"&&Number.isFinite(r)&&r>0,"isTime"),a=e((r,t)=>typeof r=="string"&&r.length>0&&r.length<=t,"isStr");function l(r){if(!SOURCE_KINDS_READ.includes(r.sourceKind)||!a(r.name,200)||typeof r.path!="string"||typeof r.intervalSec!="number")return!1;const t=r.thresholds;return o(t)&&typeof t.oldestWaitMin=="number"&&t.oldestWaitMin>0}n(l,"f"),e(l,"asDecl");function p(r){if(!o(r)||!a(r.group,1e3)||!i(r.pending))return!1;for(const u of["inFlight","failed","completedInWindow"])if(r[u]!==void 0&&!i(r[u]))return!1;const t=r.oldestPendingAt;if(t!=null&&typeof t!="string")return!1;const s=r.labels;return s===void 0||o(s)&&Object.values(s).every(u=>typeof u=="string")}n(p,"l"),e(p,"asGroup");function S(r){if(!o(r)||typeof r.at!="string"||!c(r.receivedAt)||!Array.isArray(r.groups))return!1;const t=r.totals;if(!o(t)||!i(t.groups)||!i(t.pending)||!i(t.inFlight)||!i(t.failed))return!1;const s=r.truncated;return s!==void 0&&!(o(s)&&i(s.groups))?!1:r.groups.length<=SOURCE_MAX_GROUPS&&r.groups.every(p)}n(S,"d"),e(S,"asSnapshot");export function asSourcePollRaw(r){if(!(!o(r)||r.kind!=="source-poll"||!a(r.project,200)||!l(r))&&SOURCE_POLL_STATES.includes(r.state)&&!(!c(r.polledAt)||!c(r.reportEveryMs))&&!(r.snapshot!==void 0&&!S(r.snapshot))&&!(r.state==="current"&&r.snapshot===void 0))return r}n(asSourcePollRaw,"asSourcePollRaw"),e(asSourcePollRaw,"asSourcePollRaw");export function asSourceDeclarationRaw(r){if(!(!o(r)||r.kind!=="source-declaration"||!a(r.project,200))&&!(!Array.isArray(r.sources)||!r.sources.every(t=>o(t)&&l(t)))&&!(!Array.isArray(r.problems)||!r.problems.every(t=>typeof t=="string")))return r}n(asSourceDeclarationRaw,"asSourceDeclarationRaw"),e(asSourceDeclarationRaw,"asSourceDeclarationRaw");
+"use strict";var T=Object.defineProperty;var a=(t,r)=>T(t,"name",{value:r,configurable:!0});var U=Object.defineProperty,e=a((t,r)=>U(t,"name",{value:r,configurable:!0}),"r");export const SOURCE_KINDS=["queue","loop","store","traffic"],SOURCE_KINDS_READ=["queue","loop","store","traffic"],sourceWireSchema=e(t=>`lensmcp.${t}/v1`,"sourceWireSchema"),QUEUE_WIRE_SCHEMA="lensmcp.queue/v1",LOOP_WIRE_SCHEMA="lensmcp.loop/v1",STORE_WIRE_SCHEMA="lensmcp.store/v1",TRAFFIC_WIRE_SCHEMA="lensmcp.traffic/v1",SOURCE_SNAPSHOT_FIELD={queue:"snapshot",loop:"loop",store:"store",traffic:"traffic"},URI_SOURCES="process://sources",SOURCE_PROVENANCE="reported",QUEUE_OLDEST_WAIT_RULE="queue/oldest-wait",QUEUE_STALLED_RULE="queue/stalled",LOOP_OVERDUE_RULE="loop/overdue",LOOP_FAILING_RULE="loop/failing",LOOP_IDLE_RULE="loop/idle-while-fed",STORE_QUOTA_RULE="store/near-quota",STORE_ERRORS_RULE="store/errors",STORE_ORPHANS_RULE="store/orphans",TRAFFIC_FAILURES_RULE="traffic/failures",TRAFFIC_LATENCY_RULE="traffic/latency",TRAFFIC_RATE_LIMITED_RULE="traffic/rate-limited",SOURCE_RULES=[QUEUE_OLDEST_WAIT_RULE,QUEUE_STALLED_RULE,LOOP_OVERDUE_RULE,LOOP_FAILING_RULE,LOOP_IDLE_RULE,STORE_QUOTA_RULE,STORE_ERRORS_RULE,STORE_ORPHANS_RULE,TRAFFIC_FAILURES_RULE,TRAFFIC_LATENCY_RULE,TRAFFIC_RATE_LIMITED_RULE],SOURCE_EVENT_KINDS=["source-poll","source-declaration","source-event"],CUSTOM_EVENT_SOURCE="custom",QUEUE_EVENTS=["enqueued","admitted","completed","failed","parked"],LOOP_EVENTS=["run-start","run-end"],LOOP_OUTCOMES=["ok","failed","skipped"],STORE_EVENTS=["write","delete","error"],TRAFFIC_EVENTS=["inbound","outbound"],TRAFFIC_OUTCOMES=["ok","failed","rate-limited"],SOURCE_PUSH_EVENTS={queue:QUEUE_EVENTS,loop:LOOP_EVENTS,store:STORE_EVENTS,traffic:TRAFFIC_EVENTS},SOURCE_PUSH_OUTCOMES={queue:[],loop:LOOP_OUTCOMES,store:[],traffic:TRAFFIC_OUTCOMES},SOURCE_POLL_STATES=["current","unreachable","refused","malformed","not-running"],SOURCE_STATES=[...SOURCE_POLL_STATES,"stale","never-polled"],SOURCE_DEFAULT_INTERVAL_SEC=10,SOURCE_MIN_INTERVAL_SEC=2,QUEUE_DEFAULT_OLDEST_WAIT_MIN=10,QUEUE_DEFAULT_STALLED_MIN=15,LOOP_DEFAULT_IDLE_MIN=10,LOOP_OVERDUE_INTERVALS=2,LOOP_FAILING_RUNS=3,SOURCE_FULL_REPORT_MS=6e4,SOURCE_HISTORY_POINTS=60,SOURCE_RUNS_KEPT=30,SOURCE_PUSHED_KEPT=20,STORE_DEFAULT_QUOTA_PCT=90,STORE_DEFAULT_ERROR_RATE_PCT=5,STORE_DEFAULT_ORPHAN_MIN=60,TRAFFIC_DEFAULT_FAILURE_PCT=5,TRAFFIC_DEFAULT_P95_MS=2e3,TRAFFIC_DEFAULT_RATE_LIMITED=1,TRAFFIC_MIN_MESSAGES=10,TRAFFIC_PUSH_WINDOW_MS=10*6e4,TRAFFIC_PUSH_CHANNELS=50,TRAFFIC_PUSH_EVENTS_PER_CHANNEL=1e3,SOURCE_MAX_GROUPS=500,SOURCE_MAX_BYTES=256*1024,SOURCE_STALE_PERIODS=3,SOURCE_STALE_MIN_MS=3e4;export function sourceStaleAfterMs(t){return Math.max(SOURCE_STALE_MIN_MS,SOURCE_STALE_PERIODS*Math.max(0,t))}a(sourceStaleAfterMs,"sourceStaleAfterMs"),e(sourceStaleAfterMs,"sourceStaleAfterMs");const n=e(t=>typeof t=="object"&&t!==null&&!Array.isArray(t),"isObj"),s=e(t=>typeof t=="number"&&Number.isInteger(t)&&t>=0,"isCount"),E=e(t=>typeof t=="number"&&Number.isFinite(t)&&t>0,"isTime"),u=e((t,r)=>typeof t=="string"&&t.length>0&&t.length<=r,"isStr"),v=e(t=>t===void 0||typeof t=="number"&&t>0,"isMin");function _(t){if(!SOURCE_KINDS_READ.includes(t.sourceKind)||typeof t.path!="string"&&!(t.path===void 0&&(t.sourceKind==="traffic"||t.sourceKind==="loop"))||!u(t.name,200)||typeof t.intervalSec!="number"||t.feeds!==void 0&&!u(t.feeds,200))return!1;const r=t.thresholds;if(!n(r))return!1;for(const o of["stalledMin","idleMin","oldestWaitMin","quotaPct","errorRatePct","orphanMin","failurePct","p95Ms","rateLimited"])if(!v(r[o]))return!1;return t.sourceKind!=="queue"||typeof r.oldestWaitMin=="number"}a(_,"l"),e(_,"asDecl");const l=e(t=>t===null||typeof t=="string","isIsoOrNull"),c=e(t=>t===void 0||s(t),"isOptCount");function d(t){if(!n(t)||typeof t.at!="string"||!E(t.receivedAt)||!E(t.intervalSec)||!l(t.lastRunAt)||t.nextRunAt!==void 0&&!l(t.nextRunAt))return!1;for(const r of["lastDurationMs","lastItems","runsInWindow","itemsInWindow","failuresInWindow","windowSec"])if(!c(t[r]))return!1;return t.lastOutcome!==void 0&&!LOOP_OUTCOMES.includes(t.lastOutcome)?!1:t.lastError===void 0||typeof t.lastError=="string"}a(d,"_"),e(d,"asLoopSnapshot");const f=e(t=>t===void 0||n(t)&&Object.values(t).every(r=>typeof r=="string"),"isLabels");function S(t){if(!n(t)||typeof t.at!="string"||!E(t.receivedAt)||!s(t.objects)||!s(t.bytes)||t.quotaBytes!==void 0&&t.quotaBytes!==null&&!s(t.quotaBytes))return!1;for(const i of["opsInWindow","writesInWindow","deletesInWindow","errorsInWindow","windowSec"])if(!c(t[i]))return!1;if(t.lastWriteAt!==void 0&&!l(t.lastWriteAt)||t.lastError!==void 0&&typeof t.lastError!="string")return!1;const r=t.truncated;if(r!==void 0&&!(n(r)&&s(r.groups)))return!1;const o=t.groups;return o===void 0?!0:Array.isArray(o)&&o.length<=SOURCE_MAX_GROUPS&&o.every(i=>n(i)&&u(i.group,1e3)&&s(i.objects)&&s(i.bytes)&&f(i.labels))}a(S,"S"),e(S,"asStoreSnapshot");function p(t){if(!n(t)||typeof t.at!="string"||!E(t.receivedAt)||!Array.isArray(t.channels)||!c(t.windowSec))return!1;const r=t.truncated;return r!==void 0&&!(n(r)&&s(r.channels))?!1:t.channels.length<=SOURCE_MAX_GROUPS&&t.channels.every(o=>{if(!n(o)||!u(o.channel,1e3)||!f(o.labels)||o.direction!==void 0&&o.direction!=="inbound"&&o.direction!=="outbound"||o.counterpart!==void 0&&!u(o.counterpart,200))return!1;for(const i of["messagesInWindow","failuresInWindow","rateLimitedInWindow"])if(!c(o[i]))return!1;return o.p95Ms!==void 0&&!(typeof o.p95Ms=="number"&&Number.isFinite(o.p95Ms)&&o.p95Ms>=0)||o.lastAt!==void 0&&!l(o.lastAt)?!1:o.lastError===void 0||typeof o.lastError=="string"})}a(p,"R"),e(p,"asTrafficSnapshot");function R(t){return n(t)&&u(t.digest,100)&&typeof t.at=="string"&&E(t.receivedAt)}a(R,"A"),e(R,"asSame");function A(t){if(!n(t)||!u(t.group,1e3)||!s(t.pending))return!1;for(const i of["inFlight","failed","completedInWindow"])if(t[i]!==void 0&&!s(t[i]))return!1;const r=t.oldestPendingAt;if(r!=null&&typeof r!="string")return!1;const o=t.labels;return o===void 0||n(o)&&Object.values(o).every(i=>typeof i=="string")}a(A,"O"),e(A,"asGroup");function O(t){if(!n(t)||typeof t.at!="string"||!E(t.receivedAt)||!Array.isArray(t.groups))return!1;const r=t.totals;if(!n(r)||!s(r.groups)||!s(r.pending)||!s(r.inFlight)||!s(r.failed))return!1;const o=t.truncated;return o!==void 0&&!(n(o)&&s(o.groups))?!1:t.groups.length<=SOURCE_MAX_GROUPS&&t.groups.every(A)}a(O,"T"),e(O,"asSnapshot");export function asSourcePollRaw(t){if(!n(t)||t.kind!=="source-poll"||!u(t.project,200)||!_(t)||!SOURCE_POLL_STATES.includes(t.state)||!E(t.polledAt)||!E(t.reportEveryMs)||t.path===void 0)return;const r=SOURCE_SNAPSHOT_FIELD[t.sourceKind];for(const i of Object.values(SOURCE_SNAPSHOT_FIELD))if(i!==r&&t[i]!==void 0)return;const o={snapshot:O,loop:d,store:S,traffic:p}[r];if(!(t[r]!==void 0&&!o(t[r]))&&!(t.same!==void 0&&(!R(t.same)||t[r]!==void 0))&&!(t.state==="current"&&t[r]===void 0&&t.same===void 0))return t}a(asSourcePollRaw,"asSourcePollRaw"),e(asSourcePollRaw,"asSourcePollRaw");export function asSourceEventRaw(t){if(!n(t)||t.kind!=="source-event"||!u(t.project,200)||!u(t.name,200))return;const r=t.sourceKind;if(SOURCE_KINDS_READ.includes(r)&&SOURCE_PUSH_EVENTS[r].includes(t.event)&&!(t.item!==void 0&&!u(t.item,200)||t.group!==void 0&&!u(t.group,200))&&!(!c(t.items)||!c(t.durationMs)||!c(t.bytes))&&!(t.outcome!==void 0&&!SOURCE_PUSH_OUTCOMES[r].includes(t.outcome))){for(const o of["object","channel","counterpart","correlation"])if(t[o]!==void 0&&!u(t[o],200))return;if(!(t.error!==void 0&&typeof t.error!="string"))return t}}a(asSourceEventRaw,"asSourceEventRaw"),e(asSourceEventRaw,"asSourceEventRaw");export function asSourceDeclarationRaw(t){if(!(!n(t)||t.kind!=="source-declaration"||!u(t.project,200))&&!(!Array.isArray(t.sources)||!t.sources.every(r=>n(r)&&_(r)))&&!(!Array.isArray(t.problems)||!t.problems.every(r=>typeof r=="string")))return t}a(asSourceDeclarationRaw,"asSourceDeclarationRaw"),e(asSourceDeclarationRaw,"asSourceDeclarationRaw");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lensmcp/protocol-types",
-  "version": "1.25.8",
+  "version": "1.25.10",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",