@lensmcp/protocol-types 1.25.30 → 1.25.32

package/lib/attributes.d.ts

@@ -148,8 +148,8 @@ export declare const MemoryOwnerAttrsSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type MemoryOwnerAttrs = z.infer<typeof MemoryOwnerAttrsSchema>;
 export declare const MemoryMutationOperationSchema: z.ZodEnum<{
-    push: "push";
     set: "set";
+    push: "push";
     add: "add";
     delete: "delete";
     clear: "clear";
@@ -161,8 +161,8 @@ export type MemoryMutationOperation = z.infer<typeof MemoryMutationOperationSche
 export declare const MemoryMutationAttrsSchema: z.ZodObject<{
     ownerNodeId: z.ZodString;
     operation: z.ZodEnum<{
-        push: "push";
         set: "set";
+        push: "push";
         add: "add";
         delete: "delete";
         clear: "clear";
@@ -255,9 +255,9 @@ export declare const VisualRuleTimingSchema: z.ZodEnum<{
 }>;
 export type VisualRuleTiming = z.infer<typeof VisualRuleTimingSchema>;
 export declare const VisualViolationSeveritySchema: z.ZodEnum<{
+    error: "error";
     info: "info";
     warning: "warning";
-    error: "error";
 }>;
 export type VisualViolationSeverity = z.infer<typeof VisualViolationSeveritySchema>;
 export declare const VisualViolationAttrsSchema: z.ZodObject<{
@@ -274,9 +274,9 @@ export declare const VisualViolationAttrsSchema: z.ZodObject<{
         responsive: "responsive";
     }>;
     severity: z.ZodEnum<{
+        error: "error";
         info: "info";
         warning: "warning";
-        error: "error";
     }>;
     timing: z.ZodEnum<{
         always: "always";

package/lib/context.d.ts

@@ -1,6 +1,5 @@
 import { z } from 'zod';
 export declare const FlowOriginTypeSchema: z.ZodEnum<{
-    request: "request";
     "user-click": "user-click";
     "user-input": "user-input";
     keyboard: "keyboard";
@@ -26,6 +25,7 @@ export declare const FlowOriginTypeSchema: z.ZodEnum<{
     "page-load": "page-load";
     "form-submit": "form-submit";
     "input-change": "input-change";
+    request: "request";
     job: "job";
 }>;
 export type FlowOriginType = z.infer<typeof FlowOriginTypeSchema>;
@@ -38,7 +38,6 @@ export declare const TraceContextSchema: z.ZodObject<{
     url: z.ZodOptional<z.ZodString>;
     flowId: z.ZodOptional<z.ZodString>;
     originType: z.ZodOptional<z.ZodEnum<{
-        request: "request";
         "user-click": "user-click";
         "user-input": "user-input";
         keyboard: "keyboard";
@@ -64,6 +63,7 @@ export declare const TraceContextSchema: z.ZodObject<{
         "page-load": "page-load";
         "form-submit": "form-submit";
         "input-change": "input-change";
+        request: "request";
         job: "job";
     }>>;
     originNodeId: z.ZodOptional<z.ZodString>;

package/lib/dashboard.d.ts

@@ -35,6 +35,8 @@ export interface DashHello {
     workspace: DashWorkspace;
     /** The log ring's current sequence — resume `/api/logs?since=` from here. */
     logSeq: number;
+    /** The lensmcp this dashboard runs — read at its start, so an upgrade after it started does not change it. */
+    version?: string;
 }
 /**
  * Whether the dev gateway in front of this workspace is serving.
@@ -485,6 +487,13 @@ export interface DashFlowNode {
     streamed?: boolean;
     /** A call out whose request and response were captured (`/api/exchange?id=`). */
     exchangeId?: string;
+    /**
+     * A call out to one of the cluster's own hosts (`*.localhost`): a hop through the gateway to another service, drawn
+     * in the calling service's row — not an External API.
+     */
+    hop?: true;
+    /** On a {@link hop}: the id of the request it opened (`x-lensmcp-request-id`) — the callee's leg hangs off it. */
+    calleeRequestId?: string;
     /**
      * A SQL run's every parameter and its result rows (`/api/sql-values?id=`), or a cache command's every argument and
      * its reply (`cav_`), kept beside the bus.
@@ -3563,8 +3572,23 @@ export interface DashAgentEvent {
     /** The answer's size. */
     bytes?: number;
     isError?: boolean;
-    /** What the answer said first, a line (a tool's first text; a read's MIME type). */
+    /** What the answer said first, a line (a tool's first text; a read's MIME type) — a failed call's error message. */
     result?: string;
+    /** Why it failed, when it threw: the error the agent was answered with. */
+    failure?: DashAgentFailure;
+}
+/** The error a failed call threw — its class, the lens's reason (`NOT_FOUND`, `UNAVAILABLE`…), message and stack. */
+export interface DashAgentFailure {
+    /** The error's class: `PublicMcpError`, `InvalidInputError`, `ExecutionTimeoutError`, `Error`… */
+    type: string;
+    /** Its MCP error code, when it has one (`NOT_FOUND`, `UNAVAILABLE`, `REFUSED`, `INVALID_INPUT`…). */
+    status?: string;
+    /** The message, redacted — at most 1 KB. */
+    message: string;
+    /** Its first stack frames, redacted. */
+    stack?: string;
+    /** The SDK's id for it (`err_…`), as the agent was told it. */
+    errorId?: string;
 }
 /** One MCP session — one agent connected through the lensmcp plugin and the shim to this lens. */
 export interface DashAgentSession {
@@ -3604,6 +3628,9 @@ export interface DashAgentSession {
         errors: number;
         lastMs?: number;
         p95Ms?: number;
+        /** The lensmcp the lens server runs and the shim's — each as it loaded it at its start; absent when it did not say. */
+        serverVersion?: string;
+        shimVersion?: string;
     };
     /** Newest last, at most 500. */
     events: DashAgentEvent[];
@@ -3613,3 +3640,29 @@ export interface DashAgentSessions {
     /** Live first, then by last seen; at most 20 per server. */
     sessions: DashAgentSession[];
 }
+/** One process of the lens: the dashboard, the gateway, a lens MCP server, an agent's shim. */
+export interface DashRunningVersion {
+    role: 'dashboard' | 'gateway' | 'mcp-server' | 'shim';
+    /** As a person names it: `Dashboard`, `Gateway`, `Lens MCP server`, `Claude Code's shim`. */
+    label: string;
+    pid?: number;
+    /** The lensmcp it loaded at its start — absent when it does not say (a lensmcp from before 1.25.32). */
+    version?: string;
+    startedAt?: number;
+    /**
+     * `current`: it runs the installed lensmcp. `stale`: it runs an older one — it says so, or it started before the
+     * installed one was put in place. `unknown`: neither can be told.
+     */
+    state: 'current' | 'stale' | 'unknown';
+    /** One line on how that was decided, and what loads the installed one. */
+    note: string;
+}
+export interface DashVersions {
+    at: number;
+    /** The lensmcp in this workspace's node_modules now, and when it was put there. */
+    installed?: {
+        version: string;
+        at?: number;
+    };
+    processes: DashRunningVersion[];
+}

package/lib/edge.d.ts

@@ -1,18 +1,18 @@
 import { z } from 'zod';
 export declare const EdgeAxisSchema: z.ZodEnum<{
-    state: "state";
-    network: "network";
-    data: "data";
     db: "db";
-    visual: "visual";
     memory: "memory";
+    visual: "visual";
     render: "render";
+    state: "state";
+    network: "network";
     backend: "backend";
     performance: "performance";
     lifecycle: "lifecycle";
     ownership: "ownership";
     caused: "caused";
     async: "async";
+    data: "data";
 }>;
 export type EdgeAxis = z.infer<typeof EdgeAxisSchema>;
 export declare const TraceEdgeSchema: z.ZodObject<{
@@ -20,19 +20,19 @@ export declare const TraceEdgeSchema: z.ZodObject<{
     from: z.ZodString;
     to: z.ZodString;
     axis: z.ZodEnum<{
-        state: "state";
-        network: "network";
-        data: "data";
         db: "db";
-        visual: "visual";
         memory: "memory";
+        visual: "visual";
         render: "render";
+        state: "state";
+        network: "network";
         backend: "backend";
         performance: "performance";
         lifecycle: "lifecycle";
         ownership: "ownership";
         caused: "caused";
         async: "async";
+        data: "data";
     }>;
     type: z.ZodString;
     timestamp: z.ZodNumber;

package/lib/event.d.ts

@@ -1,14 +1,5 @@
 import { z } from 'zod';
 export declare const EventSourceSchema: z.ZodEnum<{
-    gateway: "gateway";
-    ai: "ai";
-    db: "db";
-    redis: "redis";
-    queue: "queue";
-    external: "external";
-    visual: "visual";
-    react: "react";
-    memory: "memory";
     nx: "nx";
     vite: "vite";
     typescript: "typescript";
@@ -16,42 +7,51 @@ export declare const EventSourceSchema: z.ZodEnum<{
     rollup: "rollup";
     "client-runtime": "client-runtime";
     chrome: "chrome";
+    react: "react";
     valtio: "valtio";
     nestjs: "nestjs";
     nextjs: "nextjs";
+    db: "db";
+    redis: "redis";
+    queue: "queue";
+    memory: "memory";
+    visual: "visual";
     perf: "perf";
     security: "security";
+    gateway: "gateway";
+    external: "external";
+    ai: "ai";
     lens: "lens";
     custom: "custom";
 }>;
 export type EventSource = z.infer<typeof EventSourceSchema>;
 export declare const EventCategorySchema: z.ZodEnum<{
-    build: "build";
-    typecheck: "typecheck";
-    lint: "lint";
-    cluster: "cluster";
-    agent: "agent";
-    state: "state";
-    network: "network";
-    ai: "ai";
     db: "db";
-    test: "test";
-    visual: "visual";
     memory: "memory";
-    trace: "trace";
+    visual: "visual";
     security: "security";
+    ai: "ai";
+    build: "build";
+    lint: "lint";
+    typecheck: "typecheck";
+    test: "test";
     runtime: "runtime";
     render: "render";
+    trace: "trace";
+    state: "state";
+    network: "network";
     backend: "backend";
     performance: "performance";
     deps: "deps";
+    cluster: "cluster";
+    agent: "agent";
 }>;
 export type EventCategory = z.infer<typeof EventCategorySchema>;
 export declare const SeveritySchema: z.ZodEnum<{
+    error: "error";
     debug: "debug";
     info: "info";
     warning: "warning";
-    error: "error";
     fatal: "fatal";
 }>;
 export type Severity = z.infer<typeof SeveritySchema>;
@@ -60,15 +60,6 @@ export declare const BaseEventSchema: z.ZodObject<{
     sessionId: z.ZodString;
     timestamp: z.ZodNumber;
     source: z.ZodEnum<{
-        gateway: "gateway";
-        ai: "ai";
-        db: "db";
-        redis: "redis";
-        queue: "queue";
-        external: "external";
-        visual: "visual";
-        react: "react";
-        memory: "memory";
         nx: "nx";
         vite: "vite";
         typescript: "typescript";
@@ -76,40 +67,49 @@ export declare const BaseEventSchema: z.ZodObject<{
         rollup: "rollup";
         "client-runtime": "client-runtime";
         chrome: "chrome";
+        react: "react";
         valtio: "valtio";
         nestjs: "nestjs";
         nextjs: "nextjs";
+        db: "db";
+        redis: "redis";
+        queue: "queue";
+        memory: "memory";
+        visual: "visual";
         perf: "perf";
         security: "security";
+        gateway: "gateway";
+        external: "external";
+        ai: "ai";
         lens: "lens";
         custom: "custom";
     }>;
     category: z.ZodEnum<{
-        build: "build";
-        typecheck: "typecheck";
-        lint: "lint";
-        cluster: "cluster";
-        agent: "agent";
-        state: "state";
-        network: "network";
-        ai: "ai";
         db: "db";
-        test: "test";
-        visual: "visual";
         memory: "memory";
-        trace: "trace";
+        visual: "visual";
         security: "security";
+        ai: "ai";
+        build: "build";
+        lint: "lint";
+        typecheck: "typecheck";
+        test: "test";
         runtime: "runtime";
         render: "render";
+        trace: "trace";
+        state: "state";
+        network: "network";
         backend: "backend";
         performance: "performance";
         deps: "deps";
+        cluster: "cluster";
+        agent: "agent";
     }>;
     severity: z.ZodEnum<{
+        error: "error";
         debug: "debug";
         info: "info";
         warning: "warning";
-        error: "error";
         fatal: "fatal";
     }>;
     context: z.ZodObject<{
@@ -121,7 +121,6 @@ export declare const BaseEventSchema: z.ZodObject<{
         url: z.ZodOptional<z.ZodString>;
         flowId: z.ZodOptional<z.ZodString>;
         originType: z.ZodOptional<z.ZodEnum<{
-            request: "request";
             "user-click": "user-click";
             "user-input": "user-input";
             keyboard: "keyboard";
@@ -147,6 +146,7 @@ export declare const BaseEventSchema: z.ZodObject<{
             "page-load": "page-load";
             "form-submit": "form-submit";
             "input-change": "input-change";
+            request: "request";
             job: "job";
         }>>;
         originNodeId: z.ZodOptional<z.ZodString>;

package/lib/node.d.ts

@@ -1,17 +1,17 @@
 import { z } from 'zod';
 export declare const TraceNodeTypeSchema: z.ZodEnum<{
-    session: "session";
-    route: "route";
-    page: "page";
     effect: "effect";
     timer: "timer";
     "hmr-update": "hmr-update";
+    route: "route";
     render: "render";
     promise: "promise";
+    session: "session";
     "browser-context": "browser-context";
     tab: "tab";
     renderer: "renderer";
     router: "router";
+    page: "page";
     component: "component";
     element: "element";
     slot: "slot";
@@ -64,9 +64,9 @@ export declare const TraceNodeTypeSchema: z.ZodEnum<{
 }>;
 export type TraceNodeType = z.infer<typeof TraceNodeTypeSchema>;
 export declare const LifecycleSchema: z.ZodEnum<{
+    created: "created";
     active: "active";
     completed: "completed";
-    created: "created";
     disposed: "disposed";
     errored: "errored";
 }>;
@@ -75,18 +75,18 @@ export declare const TraceNodeSchema: z.ZodObject<{
     id: z.ZodString;
     parentTraceNodeId: z.ZodOptional<z.ZodString>;
     type: z.ZodEnum<{
-        session: "session";
-        route: "route";
-        page: "page";
         effect: "effect";
         timer: "timer";
         "hmr-update": "hmr-update";
+        route: "route";
         render: "render";
         promise: "promise";
+        session: "session";
         "browser-context": "browser-context";
         tab: "tab";
         renderer: "renderer";
         router: "router";
+        page: "page";
         component: "component";
         element: "element";
         slot: "slot";
@@ -141,9 +141,9 @@ export declare const TraceNodeSchema: z.ZodObject<{
     instanceId: z.ZodOptional<z.ZodString>;
     generation: z.ZodOptional<z.ZodNumber>;
     lifecycle: z.ZodEnum<{
+        created: "created";
         active: "active";
         completed: "completed";
-        created: "created";
         disposed: "disposed";
         errored: "errored";
     }>;
@@ -156,7 +156,6 @@ export declare const TraceNodeSchema: z.ZodObject<{
         url: z.ZodOptional<z.ZodString>;
         flowId: z.ZodOptional<z.ZodString>;
         originType: z.ZodOptional<z.ZodEnum<{
-            request: "request";
             "user-click": "user-click";
             "user-input": "user-input";
             keyboard: "keyboard";
@@ -182,6 +181,7 @@ export declare const TraceNodeSchema: z.ZodObject<{
             "page-load": "page-load";
             "form-submit": "form-submit";
             "input-change": "input-change";
+            request: "request";
             job: "job";
         }>>;
         originNodeId: z.ZodOptional<z.ZodString>;

package/lib/producer-health.d.ts

@@ -47,9 +47,9 @@ export type ProducerState = z.infer<typeof ProducerStateSchema>;
 /** Outcome of a producer's most recent run. */
 export declare const ProducerRunStatusSchema: z.ZodEnum<{
     error: "error";
+    running: "running";
     clean: "clean";
     failing: "failing";
-    running: "running";
 }>;
 export type ProducerRunStatus = z.infer<typeof ProducerRunStatusSchema>;
 /**
@@ -66,9 +66,9 @@ export declare const ProducerReportSchema: z.ZodObject<{
     lastReportedAt: z.ZodNumber;
     lastRunStatus: z.ZodEnum<{
         error: "error";
+        running: "running";
         clean: "clean";
         failing: "failing";
-        running: "running";
     }>;
     lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
     errorCount: z.ZodNumber;
@@ -93,9 +93,9 @@ export declare const ProducerHealthSchema: z.ZodObject<{
         lastReportedAt: z.ZodNumber;
         lastRunStatus: z.ZodEnum<{
             error: "error";
+            running: "running";
             clean: "clean";
             failing: "failing";
-            running: "running";
         }>;
         lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
         errorCount: z.ZodNumber;

package/lib/replay.d.ts

@@ -129,6 +129,8 @@ export type DashReplayStoryItem = {
     valuesId?: string;
     /** A call out's captured request and response. */
     exchangeId?: string;
+    /** A call to one of the cluster's own services through the gateway (`DashFlowNode.hop`), not a call out. */
+    hop?: true;
     /** An AI call's prompt and completion — `ai_get_call { callId }`. */
     aiCallId?: string;
     /** The lane's node a system item tells (`DashFlowNode.id`) — what the dashboard's player lights. */

package/lib/resources.d.ts

@@ -14,18 +14,18 @@ export declare const ResourceEnvelopeSchema: z.ZodObject<{
 export type ResourceEnvelope = z.infer<typeof ResourceEnvelopeSchema>;
 export declare const AgentStatusKindSchema: z.ZodEnum<{
     warning: "warning";
-    starting: "starting";
     clean: "clean";
     failing: "failing";
+    starting: "starting";
 }>;
 export type AgentStatusKind = z.infer<typeof AgentStatusKindSchema>;
 export declare const AgentBlockingItemSchema: z.ZodObject<{
     source: z.ZodString;
     severity: z.ZodEnum<{
+        error: "error";
         debug: "debug";
         info: "info";
         warning: "warning";
-        error: "error";
         fatal: "fatal";
     }>;
     title: z.ZodString;
@@ -50,36 +50,36 @@ export type AgentBlockingItem = z.infer<typeof AgentBlockingItemSchema>;
 export declare const AgentChecksSchema: z.ZodObject<{
     typecheck: z.ZodOptional<z.ZodEnum<{
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
     lint: z.ZodOptional<z.ZodEnum<{
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
     build: z.ZodOptional<z.ZodEnum<{
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
     runtime: z.ZodOptional<z.ZodEnum<{
         warning: "warning";
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
     visual: z.ZodOptional<z.ZodEnum<{
         warning: "warning";
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
     memory: z.ZodOptional<z.ZodEnum<{
         warning: "warning";
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
 }, z.core.$strip>;
 /**
@@ -114,19 +114,19 @@ export declare const AgentCurrentStatusSchema: z.ZodObject<{
     sessionId: z.ZodString;
     status: z.ZodEnum<{
         warning: "warning";
-        starting: "starting";
         clean: "clean";
         failing: "failing";
+        starting: "starting";
     }>;
     activeTab: z.ZodOptional<z.ZodString>;
     tabsWithIssues: z.ZodOptional<z.ZodArray<z.ZodString>>;
     blocking: z.ZodArray<z.ZodObject<{
         source: z.ZodString;
         severity: z.ZodEnum<{
+            error: "error";
             debug: "debug";
             info: "info";
             warning: "warning";
-            error: "error";
             fatal: "fatal";
         }>;
         title: z.ZodString;
@@ -150,10 +150,10 @@ export declare const AgentCurrentStatusSchema: z.ZodObject<{
     warnings: z.ZodDefault<z.ZodArray<z.ZodObject<{
         source: z.ZodString;
         severity: z.ZodEnum<{
+            error: "error";
             debug: "debug";
             info: "info";
             warning: "warning";
-            error: "error";
             fatal: "fatal";
         }>;
         title: z.ZodString;
@@ -178,36 +178,36 @@ export declare const AgentCurrentStatusSchema: z.ZodObject<{
     checks: z.ZodOptional<z.ZodObject<{
         typecheck: z.ZodOptional<z.ZodEnum<{
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
         lint: z.ZodOptional<z.ZodEnum<{
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
         build: z.ZodOptional<z.ZodEnum<{
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
         runtime: z.ZodOptional<z.ZodEnum<{
             warning: "warning";
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
         visual: z.ZodOptional<z.ZodEnum<{
             warning: "warning";
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
         memory: z.ZodOptional<z.ZodEnum<{
             warning: "warning";
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
     }, z.core.$strip>>;
     server: z.ZodOptional<z.ZodObject<{
@@ -327,10 +327,10 @@ declare const CheckEntrySchema: z.ZodObject<{
     code: z.ZodOptional<z.ZodString>;
     rule: z.ZodOptional<z.ZodString>;
     severity: z.ZodOptional<z.ZodEnum<{
+        error: "error";
         debug: "debug";
         info: "info";
         warning: "warning";
-        error: "error";
         fatal: "fatal";
     }>>;
     file: z.ZodOptional<z.ZodString>;
@@ -356,9 +356,9 @@ export declare const TypecheckCurrentSchema: z.ZodObject<{
         lastReportedAt: z.ZodNumber;
         lastRunStatus: z.ZodEnum<{
             error: "error";
+            running: "running";
             clean: "clean";
             failing: "failing";
-            running: "running";
         }>;
         lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
         errorCount: z.ZodNumber;
@@ -395,9 +395,9 @@ export declare const TypecheckErrorsSchema: z.ZodObject<{
         lastReportedAt: z.ZodNumber;
         lastRunStatus: z.ZodEnum<{
             error: "error";
+            running: "running";
             clean: "clean";
             failing: "failing";
-            running: "running";
         }>;
         lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
         errorCount: z.ZodNumber;
@@ -416,10 +416,10 @@ export declare const TypecheckErrorsSchema: z.ZodObject<{
         code: z.ZodOptional<z.ZodString>;
         rule: z.ZodOptional<z.ZodString>;
         severity: z.ZodOptional<z.ZodEnum<{
+            error: "error";
             debug: "debug";
             info: "info";
             warning: "warning";
-            error: "error";
             fatal: "fatal";
         }>>;
         file: z.ZodOptional<z.ZodString>;
@@ -446,9 +446,9 @@ export declare const LintCurrentSchema: z.ZodObject<{
         lastReportedAt: z.ZodNumber;
         lastRunStatus: z.ZodEnum<{
             error: "error";
+            running: "running";
             clean: "clean";
             failing: "failing";
-            running: "running";
         }>;
         lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
         errorCount: z.ZodNumber;
@@ -487,9 +487,9 @@ export declare const BuildCurrentSchema: z.ZodObject<{
         lastReportedAt: z.ZodNumber;
         lastRunStatus: z.ZodEnum<{
             error: "error";
+            running: "running";
             clean: "clean";
             failing: "failing";
-            running: "running";
         }>;
         lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
         errorCount: z.ZodNumber;

package/package.json

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