rpcgrpc

type AppLogCallback func(entry *AppLogEntry)

type AppLogEntry struct {
	TimestampNs int64             `protobuf:"varint,1,opt,name=timestamp_ns,json=timestampNs,proto3" json:"timestamp_ns,omitempty"` // entry time as Unix nanoseconds
	Level       string            `protobuf:"bytes,2,opt,name=level,proto3" json:"level,omitempty"`                                 // "trace"|"debug"|"info"|"warn"|"error"|"fatal"|"panic"
	Module      string            `protobuf:"bytes,3,opt,name=module,proto3" json:"module,omitempty"`                               // _module field (e.g. "router", "skysocks-client")
	Message     string            `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`                             // formatted message text
	Fields      map[string]string ``                                                                                                // remaining structured fields
	/* 139-byte string literal not displayed */
	// Subscribed is set on a sentinel entry the server sends
	// immediately after it has registered the subscription with the
	// broadcaster. Clients use this to know that any subsequent log
	// activity will reach them — letting them gate downstream RPC
	// calls (e.g. StartAppWithMode) on subscription readiness so the
	// first ~50ms of setup logs aren't lost to the race between
	// subscription handshake and the action that triggers them.
	// The other fields are unused on the sentinel.
	Subscribed bool `protobuf:"varint,6,opt,name=subscribed,proto3" json:"subscribed,omitempty"`
	// contains filtered or unexported fields
}

type AppLogStreamRequest struct {

	// AppName scopes the stream to entries originating from this app's
	// module or carrying app=<name> as a logrus field. Either AppName
	// or Modules (or both) must be set.
	AppName string `protobuf:"bytes,1,opt,name=app_name,json=appName,proto3" json:"app_name,omitempty"`
	// IncludeRouter is retained on the wire for forward compatibility
	// but is ignored — the app_name field tagging now covers what it
	// used to do, and Modules below is the explicit path for non-app
	// scoping (e.g. 'cli dmsg curl --verbose' picking up dmsg layers).
	IncludeRouter bool `protobuf:"varint,2,opt,name=include_router,json=includeRouter,proto3" json:"include_router,omitempty"`
	// MinLevel filters out lower-severity entries: trace|debug|info|warn|error.
	// Default debug.
	MinLevel string `protobuf:"bytes,3,opt,name=min_level,json=minLevel,proto3" json:"min_level,omitempty"`
	// Modules filters by _module prefix, OR-merged with the AppName
	// match. Use this when no app context exists — e.g. 'dmsg curl
	// --verbose' sends ["dmsgC","dmsghttp","dmsg_grpc"]. Empty means
	// "no module-prefix match"; AppName is then the only path.
	Modules []string `protobuf:"bytes,4,rep,name=modules,proto3" json:"modules,omitempty"`
	// contains filtered or unexported fields
}

type BandwidthProgress struct {
	BytesSent     uint64  `protobuf:"varint,1,opt,name=bytes_sent,json=bytesSent,proto3" json:"bytes_sent,omitempty"`              // Cumulative bytes sent
	BytesReceived uint64  `protobuf:"varint,2,opt,name=bytes_received,json=bytesReceived,proto3" json:"bytes_received,omitempty"`  // Cumulative bytes received
	ElapsedNs     int64   `protobuf:"varint,3,opt,name=elapsed_ns,json=elapsedNs,proto3" json:"elapsed_ns,omitempty"`              // Elapsed time in nanoseconds
	UploadSpeed   float64 `protobuf:"fixed64,4,opt,name=upload_speed,json=uploadSpeed,proto3" json:"upload_speed,omitempty"`       // Current upload speed in KB/s
	DownloadSpeed float64 `protobuf:"fixed64,5,opt,name=download_speed,json=downloadSpeed,proto3" json:"download_speed,omitempty"` // Current download speed in KB/s
	IsFinal       bool    `protobuf:"varint,6,opt,name=is_final,json=isFinal,proto3" json:"is_final,omitempty"`                    // True if this is the final result
	Error         string  `protobuf:"bytes,7,opt,name=error,proto3" json:"error,omitempty"`                                        // Error message if test failed
	// contains filtered or unexported fields
}

type BandwidthProgressCallback func(bytesSent, bytesReceived uint64, elapsed time.Duration, uploadSpeed, downloadSpeed float64, isFinal bool, err error)

type BandwidthRequest struct {
	PublicKey    string `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`             // Target visor public key
	DurationNs   int64  `protobuf:"varint,2,opt,name=duration_ns,json=durationNs,proto3" json:"duration_ns,omitempty"`         // Duration to run the test in nanoseconds
	PacketSizeKb int32  `protobuf:"varint,3,opt,name=packet_size_kb,json=packetSizeKb,proto3" json:"packet_size_kb,omitempty"` // Packet size in KB (default 32)
	LocalRoute   bool   `protobuf:"varint,4,opt,name=local_route,json=localRoute,proto3" json:"local_route,omitempty"`         // Use local route calculation (for skywire route)
	// contains filtered or unexported fields
}

type CalcHop struct {
	TpId string `protobuf:"bytes,1,opt,name=tp_id,json=tpId,proto3" json:"tp_id,omitempty"`
	From string `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
	To   string `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
	// contains filtered or unexported fields
}

type CalcRoute struct {
	Hops []*CalcHop `protobuf:"bytes,1,rep,name=hops,proto3" json:"hops,omitempty"`
	// contains filtered or unexported fields
}

type CalcRouteCallback func(route *CalcRoute) bool

type CalcRoutesRequest struct {

	// SrcPk is the source visor public key. Empty means use the receiving
	// visor's own PK (the common case — calc routes from this visor).
	SrcPk string `protobuf:"bytes,1,opt,name=src_pk,json=srcPk,proto3" json:"src_pk,omitempty"`
	// DstPk is the destination visor public key. Required.
	DstPk string `protobuf:"bytes,2,opt,name=dst_pk,json=dstPk,proto3" json:"dst_pk,omitempty"`
	// MinHops is the minimum hop count. 0 falls back to the visor's
	// routing.min_hops, then 1.
	MinHops int32 `protobuf:"varint,3,opt,name=min_hops,json=minHops,proto3" json:"min_hops,omitempty"`
	// MaxHops is the maximum hop count. 0 falls back to a safe default.
	MaxHops int32 `protobuf:"varint,4,opt,name=max_hops,json=maxHops,proto3" json:"max_hops,omitempty"`
	// Count caps how many routes to return. 0 means unbounded (the BFS
	// runs until the search space is exhausted; the streaming wire
	// protocol means the caller can still dump them as they arrive
	// without buffering the whole set).
	Count int32 `protobuf:"varint,5,opt,name=count,proto3" json:"count,omitempty"`
	// Source selects the transport-graph data source. "tpd" (HTTP),
	// "dht" (visor's local DHT store), or "auto" (DHT then TPD fallback).
	Source string `protobuf:"bytes,6,opt,name=source,proto3" json:"source,omitempty"`
	// TpdUrl optionally overrides the default transport-discovery URL.
	TpdUrl string `protobuf:"bytes,7,opt,name=tpd_url,json=tpdUrl,proto3" json:"tpd_url,omitempty"`
	// QueueCap caps the per-call BFS queue size on the server. 0 falls
	// back to the route-finder package's DefaultMaxBFSQueue. Negative
	// means unbounded (use with caution on dense graphs).
	QueueCap int32 `protobuf:"varint,8,opt,name=queue_cap,json=queueCap,proto3" json:"queue_cap,omitempty"`
	// contains filtered or unexported fields
}

type CpuStat struct {
	Cpu          string  `protobuf:"bytes,1,opt,name=cpu,proto3" json:"cpu,omitempty"`                                         // CPU identifier (cpu0, cpu1, etc. or cpu-total)
	UsagePercent float64 `protobuf:"fixed64,2,opt,name=usage_percent,json=usagePercent,proto3" json:"usage_percent,omitempty"` // Usage percentage (0-100)
	// contains filtered or unexported fields
}

type DiskStat struct {
	Device      string  `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`                                // Device name
	Mountpoint  string  `protobuf:"bytes,2,opt,name=mountpoint,proto3" json:"mountpoint,omitempty"`                        // Mount point
	Fstype      string  `protobuf:"bytes,3,opt,name=fstype,proto3" json:"fstype,omitempty"`                                // Filesystem type
	Total       uint64  `protobuf:"varint,4,opt,name=total,proto3" json:"total,omitempty"`                                 // Total space in bytes
	Used        uint64  `protobuf:"varint,5,opt,name=used,proto3" json:"used,omitempty"`                                   // Used space in bytes
	Free        uint64  `protobuf:"varint,6,opt,name=free,proto3" json:"free,omitempty"`                                   // Free space in bytes
	UsedPercent float64 `protobuf:"fixed64,7,opt,name=used_percent,json=usedPercent,proto3" json:"used_percent,omitempty"` // Usage percentage (0-100)
	// contains filtered or unexported fields
}

type DmsgServersRequest struct {
	PublicKey string `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` // Remote visor public key to look up
	// contains filtered or unexported fields
}

type DmsgServersResponse struct {
	ServerPks []string `protobuf:"bytes,1,rep,name=server_pks,json=serverPks,proto3" json:"server_pks,omitempty"` // List of DMSG server public keys
	// contains filtered or unexported fields
}

type GroupMessageCallback func(e *GroupMessageEvent)

type GroupMessageData struct {
	TimestampNs int64
	GroupID     string
	SenderPK    string
	Body        string
}

type GroupMessageEvent struct {

	// TimestampNs is the message Unix-nanos timestamp from the sender.
	TimestampNs int64 `protobuf:"varint,1,opt,name=timestamp_ns,json=timestampNs,proto3" json:"timestamp_ns,omitempty"`
	// GroupId is the group the message arrived on.
	GroupId string `protobuf:"bytes,2,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
	// SenderPk is the publishing member's hex public key.
	SenderPk string `protobuf:"bytes,3,opt,name=sender_pk,json=senderPk,proto3" json:"sender_pk,omitempty"`
	// Body is the message text (may contain embedded newlines —
	// callers that need one-line-per-event should escape on display).
	Body string `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"`
	// Subscribed is set on a sentinel sent immediately after the
	// server registers the subscription. Lets clients gate downstream
	// RPCs on subscription liveness — same pattern AppLogEntry uses.
	Subscribed bool `protobuf:"varint,5,opt,name=subscribed,proto3" json:"subscribed,omitempty"`
	// contains filtered or unexported fields
}

type GroupMessagesRequest struct {

	// GroupId filters to one group. Empty subscribes to every group
	// the visor is currently in (the default 'cli skychat group listen'
	// behavior).
	GroupId string `protobuf:"bytes,1,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
	// SinceTimestampNs replays buffered messages with TS strictly
	// greater than this value before live deliveries start. Zero
	// means "live only" — drains nothing from history. Mirrors the
	// 'since' arg the previous GroupPoll RPC accepted.
	SinceTimestampNs int64 `protobuf:"varint,2,opt,name=since_timestamp_ns,json=sinceTimestampNs,proto3" json:"since_timestamp_ns,omitempty"`
	// contains filtered or unexported fields
}

type HostInfo struct {
	Hostname        string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	UptimeSec       int64  `protobuf:"varint,2,opt,name=uptime_sec,json=uptimeSec,proto3" json:"uptime_sec,omitempty"`                  // System uptime in seconds
	Os              string `protobuf:"bytes,3,opt,name=os,proto3" json:"os,omitempty"`                                                  // Operating system name
	Platform        string `protobuf:"bytes,4,opt,name=platform,proto3" json:"platform,omitempty"`                                      // Platform (e.g., ubuntu, centos)
	PlatformVersion string `protobuf:"bytes,5,opt,name=platform_version,json=platformVersion,proto3" json:"platform_version,omitempty"` // Platform version
	KernelVersion   string `protobuf:"bytes,6,opt,name=kernel_version,json=kernelVersion,proto3" json:"kernel_version,omitempty"`       // Kernel version
	KernelArch      string `protobuf:"bytes,7,opt,name=kernel_arch,json=kernelArch,proto3" json:"kernel_arch,omitempty"`                // Kernel architecture
	NumCpus         int32  `protobuf:"varint,8,opt,name=num_cpus,json=numCpus,proto3" json:"num_cpus,omitempty"`                        // Number of logical CPUs
	// contains filtered or unexported fields
}

type MemoryStat struct {
	Total       uint64  `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`                                 // Total memory in bytes
	Used        uint64  `protobuf:"varint,2,opt,name=used,proto3" json:"used,omitempty"`                                   // Used memory in bytes
	Available   uint64  `protobuf:"varint,3,opt,name=available,proto3" json:"available,omitempty"`                         // Available memory in bytes
	UsedPercent float64 `protobuf:"fixed64,4,opt,name=used_percent,json=usedPercent,proto3" json:"used_percent,omitempty"` // Usage percentage (0-100)
	// contains filtered or unexported fields
}

type MuxBandwidthDone struct {
	TotalBytesSent     uint64 `protobuf:"varint,1,opt,name=total_bytes_sent,json=totalBytesSent,proto3" json:"total_bytes_sent,omitempty"`
	TotalBytesReceived uint64 `protobuf:"varint,2,opt,name=total_bytes_received,json=totalBytesReceived,proto3" json:"total_bytes_received,omitempty"`
	// WallTimeNs is total elapsed including setup; PumpTimeNs excludes
	// setup. Operators comparing throughput across runs typically want
	// PumpTimeNs (apples-to-apples regardless of how long setup took).
	WallTimeNs        int64   `protobuf:"varint,3,opt,name=wall_time_ns,json=wallTimeNs,proto3" json:"wall_time_ns,omitempty"`
	PumpTimeNs        int64   `protobuf:"varint,4,opt,name=pump_time_ns,json=pumpTimeNs,proto3" json:"pump_time_ns,omitempty"`
	AvgSendBps        float64 `protobuf:"fixed64,5,opt,name=avg_send_bps,json=avgSendBps,proto3" json:"avg_send_bps,omitempty"`
	AvgRecvBps        float64 `protobuf:"fixed64,6,opt,name=avg_recv_bps,json=avgRecvBps,proto3" json:"avg_recv_bps,omitempty"`
	PeakSendBps       float64 `protobuf:"fixed64,7,opt,name=peak_send_bps,json=peakSendBps,proto3" json:"peak_send_bps,omitempty"`
	PeakRecvBps       float64 `protobuf:"fixed64,8,opt,name=peak_recv_bps,json=peakRecvBps,proto3" json:"peak_recv_bps,omitempty"`
	RoutesRequested   int32   `protobuf:"varint,9,opt,name=routes_requested,json=routesRequested,proto3" json:"routes_requested,omitempty"`
	RoutesEstablished int32   `protobuf:"varint,10,opt,name=routes_established,json=routesEstablished,proto3" json:"routes_established,omitempty"`
	SetupTotalNs      int64   `protobuf:"varint,11,opt,name=setup_total_ns,json=setupTotalNs,proto3" json:"setup_total_ns,omitempty"`
	// RTT distribution under load — across all probes that fired
	// during the bulk pump phase. Zero when no probes ran or
	// ProbeRtt was false. Jitter is population stddev — same
	// formula as PingTreeResult.jitter_ns.
	ProbeCount    int32 `protobuf:"varint,12,opt,name=probe_count,json=probeCount,proto3" json:"probe_count,omitempty"`
	ProbeAvgNs    int64 `protobuf:"varint,13,opt,name=probe_avg_ns,json=probeAvgNs,proto3" json:"probe_avg_ns,omitempty"`
	ProbeP50Ns    int64 `protobuf:"varint,14,opt,name=probe_p50_ns,json=probeP50Ns,proto3" json:"probe_p50_ns,omitempty"`
	ProbeP99Ns    int64 `protobuf:"varint,15,opt,name=probe_p99_ns,json=probeP99Ns,proto3" json:"probe_p99_ns,omitempty"`
	ProbeJitterNs int64 `protobuf:"varint,16,opt,name=probe_jitter_ns,json=probeJitterNs,proto3" json:"probe_jitter_ns,omitempty"`
	// TerminationReason: "duration" | "context_cancel" | "all_routes_failed" | "error".
	TerminationReason string `protobuf:"bytes,17,opt,name=termination_reason,json=terminationReason,proto3" json:"termination_reason,omitempty"`
	// RTT distribution under no contention — across all probes that
	// fired during the IdleBaselineDuration phase BEFORE the bulk
	// pump. Zero when idle_baseline_duration_ns was 0 or no probes
	// landed in the window. Operators compute the queueing delay
	// as (probe_pXX - idle_probe_pXX); the CLI's summary prints
	// this delta directly when both distributions are present.
	IdleProbeCount    int32 `protobuf:"varint,18,opt,name=idle_probe_count,json=idleProbeCount,proto3" json:"idle_probe_count,omitempty"`
	IdleProbeAvgNs    int64 `protobuf:"varint,19,opt,name=idle_probe_avg_ns,json=idleProbeAvgNs,proto3" json:"idle_probe_avg_ns,omitempty"`
	IdleProbeP50Ns    int64 `protobuf:"varint,20,opt,name=idle_probe_p50_ns,json=idleProbeP50Ns,proto3" json:"idle_probe_p50_ns,omitempty"`
	IdleProbeP99Ns    int64 `protobuf:"varint,21,opt,name=idle_probe_p99_ns,json=idleProbeP99Ns,proto3" json:"idle_probe_p99_ns,omitempty"`
	IdleProbeJitterNs int64 `protobuf:"varint,22,opt,name=idle_probe_jitter_ns,json=idleProbeJitterNs,proto3" json:"idle_probe_jitter_ns,omitempty"`
	// contains filtered or unexported fields
}

type MuxBandwidthError struct {
	Code    string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// contains filtered or unexported fields
}

type MuxBandwidthEvent struct {
	TimestampNs int64 `protobuf:"varint,1,opt,name=timestamp_ns,json=timestampNs,proto3" json:"timestamp_ns,omitempty"`
	// Types that are valid to be assigned to Payload:
	//
	//	*MuxBandwidthEvent_RouteEstablished
	//	*MuxBandwidthEvent_Sample
	//	*MuxBandwidthEvent_RttProbe
	//	*MuxBandwidthEvent_Done
	//	*MuxBandwidthEvent_Error
	//	*MuxBandwidthEvent_RouteFailure
	//	*MuxBandwidthEvent_LegLifecycle
	Payload isMuxBandwidthEvent_Payload `protobuf_oneof:"payload"`
	// contains filtered or unexported fields
}

type MuxBandwidthEvent_Done struct {
	// Done is the terminal event before stream close. Carries the
	// aggregated totals + RTT distribution stats.
	Done *MuxBandwidthDone `protobuf:"bytes,13,opt,name=done,proto3,oneof"`
}

type MuxBandwidthEvent_Error struct {
	// Error signals an unrecoverable condition. Last event before
	// stream close; same shape semantics as PingTreeServerError.
	Error *MuxBandwidthError `protobuf:"bytes,14,opt,name=error,proto3,oneof"`
}

type MuxBandwidthEvent_LegLifecycle struct {
	// LegLifecycle fires when the routing-policy on_tick hook mutates the
	// leg set — a leg added, dropped, promoted from warm standby, or demoted
	// to it. Only emitted on policy-driven (`policy-bw`) runs; the pure
	// mux-bw baseline never mutates its leg set mid-run so never emits these.
	// Lets the telemetry chart render hot-swaps against the per-leg bandwidth
	// series.
	LegLifecycle *MuxLegLifecycle `protobuf:"bytes,16,opt,name=leg_lifecycle,json=legLifecycle,proto3,oneof"`
}

type MuxBandwidthEvent_RouteEstablished struct {
	// RouteEstablished fires once per route (in any order) as the
	// setup phase completes. Carries the actual route hops chosen,
	// letting consumers verify min_hops was honored.
	RouteEstablished *MuxRouteEstablished `protobuf:"bytes,10,opt,name=route_established,json=routeEstablished,proto3,oneof"`
}

type MuxBandwidthEvent_RouteFailure struct {
	// RouteFailure fires when a route's pump goroutine exits with an
	// error AFTER the route was established. Distinct from
	// MuxRouteEstablished{failed:true,setup_err:...} which covers
	// setup-phase failures. Carries the partial bytes shipped before
	// the pump goroutine died so the consumer can attribute throughput
	// contributions accurately.
	RouteFailure *MuxRouteFailure `protobuf:"bytes,15,opt,name=route_failure,json=routeFailure,proto3,oneof"`
}

type MuxBandwidthEvent_RttProbe struct {
	// RttProbe fires every probe_interval_ns when ProbeRtt is set.
	// Standalone from the Sample event because probes are async.
	RttProbe *MuxRttProbe `protobuf:"bytes,12,opt,name=rtt_probe,json=rttProbe,proto3,oneof"`
}

type MuxBandwidthEvent_Sample struct {
	// Sample fires every sample_interval_ns with cumulative + instant
	// throughput numbers. Sent until pump duration elapses.
	Sample *MuxBandwidthSample `protobuf:"bytes,11,opt,name=sample,proto3,oneof"`
}

type MuxBandwidthRequest struct {

	// TargetPk is the remote visor's public key. Required.
	TargetPk string `protobuf:"bytes,1,opt,name=target_pk,json=targetPk,proto3" json:"target_pk,omitempty"`
	// Routes is the number of parallel route connections to open.
	// 1 = single route (the StreamBandwidthTest equivalent).
	// N > 1 = N concurrent routes pumping bytes, aggregate throughput
	// is the headline measurement. 0 falls back to 1.
	Routes int32 `protobuf:"varint,2,opt,name=routes,proto3" json:"routes,omitempty"`
	// DurationNs caps the total wall-clock time spent pumping bytes.
	// 0 falls back to 30s.
	DurationNs int64 `protobuf:"varint,3,opt,name=duration_ns,json=durationNs,proto3" json:"duration_ns,omitempty"`
	// PacketSizeKb sizes each write block. Larger amortizes write
	// overhead; smaller surfaces stalls faster. 0 falls back to 32 KB.
	PacketSizeKb int32 `protobuf:"varint,4,opt,name=packet_size_kb,json=packetSizeKb,proto3" json:"packet_size_kb,omitempty"`
	// MinHops is the route-finder's minimum hop constraint. When > 1,
	// the route excludes any direct transport between the local visor
	// and TargetPk — forcing the bandwidth pump through intermediates.
	// This is the "mux excluding direct" cell of the operator's
	// hypothesis. 0 uses the visor's routing.min_hops config default
	// (usually 1).
	MinHops int32 `protobuf:"varint,5,opt,name=min_hops,json=minHops,proto3" json:"min_hops,omitempty"`
	// SetupTimeoutNs bounds each route's setup phase. 0 falls back to
	// 30s. Long setup times are common for multi-hop routes (see the
	// p95=9.5s level-1 setup numbers from the ping-tree measurement).
	SetupTimeoutNs int64 `protobuf:"varint,6,opt,name=setup_timeout_ns,json=setupTimeoutNs,proto3" json:"setup_timeout_ns,omitempty"`
	// ProbeRtt toggles a separate small-packet RTT probe that runs
	// concurrently with the bulk pump. Pairs are emitted as
	// MuxRttProbe events. The probe rides the SAME first route as the
	// bulk pump, so the resulting RTT samples reflect that route's
	// saturation — the queueing-delay signal.
	ProbeRtt bool `protobuf:"varint,7,opt,name=probe_rtt,json=probeRtt,proto3" json:"probe_rtt,omitempty"`
	// ProbeIntervalNs is how often the RTT probe fires. 0 falls back
	// to 100 ms. Faster = denser jitter signal; slower = less
	// contention with the bulk pump.
	ProbeIntervalNs int64 `protobuf:"varint,8,opt,name=probe_interval_ns,json=probeIntervalNs,proto3" json:"probe_interval_ns,omitempty"`
	// SampleIntervalNs is how often a MuxBandwidthSample is emitted.
	// 0 falls back to 1s. Smaller surfaces transient throughput dips
	// (bufferbloat, queue spikes); larger reduces stream chatter.
	SampleIntervalNs int64 `protobuf:"varint,9,opt,name=sample_interval_ns,json=sampleIntervalNs,proto3" json:"sample_interval_ns,omitempty"`
	// LocalRoute uses local route calculation (cached TPD data)
	// instead of querying the route-finder service. Mirrors
	// BandwidthRequest.LocalRoute.
	LocalRoute bool `protobuf:"varint,10,opt,name=local_route,json=localRoute,proto3" json:"local_route,omitempty"`
	// IdleBaselineDurationNs, when > 0, inserts a quiescent probe
	// phase between route setup and the bulk pump. During the phase
	// the same probe loop fires (rate = probe_interval_ns) but no
	// pump goroutines run — so the RTT samples reflect the route
	// with zero contention. The aggregated distribution comes back
	// in MuxBandwidthDone.idle_probe_* fields, and the queueing
	// delay computed by callers is (loaded_pXX - idle_pXX). 0 = no
	// idle phase (skip the baseline measurement). Implies ProbeRtt =
	// true at the handler — without probes there's nothing to
	// measure.
	IdleBaselineDurationNs int64 `` /* 133-byte string literal not displayed */
	// RoutingPolicy, when non-empty, drives this run through the WASM /
	// Starlark routing-policy engine instead of the pure-measurement path.
	// Accepts the same values as the visor's routing.policy_per_dial config:
	// "preset:<name>" (a compiled bundle preset — rotating-bw, elastic-mux,
	// latency-adaptive, app-mux, adaptive, probe-and-prune), "@/path/to.wasm",
	// "@/path/to.star", or an inline Starlark string. When set, the handler
	// (a) calls the engine's decide_route to pick the mux leg count + min-hops
	// at setup, and (b) fires the engine's on_tick hook against the live per-leg
	// stats on the sample cadence, applying the returned add/drop/promote/demote
	// leg actions — the in-process rig that proves a preset is demonstrably
	// adaptive over a live multiplexed route. Empty = the untouched mux-bw
	// baseline. This is the `policy-bw` CLI sibling's surface.
	RoutingPolicy string `protobuf:"bytes,12,opt,name=routing_policy,json=routingPolicy,proto3" json:"routing_policy,omitempty"`
	// PolicyApp is the app name the routing-policy engine sees as
	// RoutingContext.App — presets branch on it (latency-adaptive acts on
	// vpn-client/skysocks-client/skynet-client; app-mux is per-app). Only
	// meaningful when routing_policy is set; the handler defaults it to
	// "skysocks-client" so the bandwidth-oriented presets are exercised.
	PolicyApp string `protobuf:"bytes,13,opt,name=policy_app,json=policyApp,proto3" json:"policy_app,omitempty"`
	// CliOverrides surfaces the operator's ad-hoc `--override key=value` flags
	// into the routing-policy engine's RoutingContext.CLIOverrides — the same
	// map the conditional presets read: geo-avoid (avoid_geo=<CC,CC>),
	// trust-tiered (trusted_pks=<PK,PK>), time-of-day (business_hours=START-END).
	// Only meaningful when routing_policy is set. Absent/empty = the preset's
	// built-in defaults (unchanged behavior). Keys collide-last with the
	// handler-derived mux_routes / min_hops entries the controller already sets.
	CliOverrides map[string]string `` /* 172-byte string literal not displayed */
	// contains filtered or unexported fields
}

type MuxBandwidthSample struct {

	// ElapsedNs is the time since the first byte was sent (NOT since
	// the run was requested — excludes setup time).
	ElapsedNs     int64  `protobuf:"varint,1,opt,name=elapsed_ns,json=elapsedNs,proto3" json:"elapsed_ns,omitempty"`
	BytesSent     uint64 `protobuf:"varint,2,opt,name=bytes_sent,json=bytesSent,proto3" json:"bytes_sent,omitempty"`
	BytesReceived uint64 `protobuf:"varint,3,opt,name=bytes_received,json=bytesReceived,proto3" json:"bytes_received,omitempty"`
	// InstantSendBps / RecvBps are per-interval rates. avg_*_bps are
	// run-cumulative rates. All in bits-per-second (matches the
	// network-engineer convention; consumers needing Mbps divide by
	// 1e6).
	InstantSendBps float64 `protobuf:"fixed64,4,opt,name=instant_send_bps,json=instantSendBps,proto3" json:"instant_send_bps,omitempty"`
	InstantRecvBps float64 `protobuf:"fixed64,5,opt,name=instant_recv_bps,json=instantRecvBps,proto3" json:"instant_recv_bps,omitempty"`
	AvgSendBps     float64 `protobuf:"fixed64,6,opt,name=avg_send_bps,json=avgSendBps,proto3" json:"avg_send_bps,omitempty"`
	AvgRecvBps     float64 `protobuf:"fixed64,7,opt,name=avg_recv_bps,json=avgRecvBps,proto3" json:"avg_recv_bps,omitempty"`
	// ActiveRoutes is how many of the Routes-requested routes are
	// still pumping. Drops when a route fails mid-run.
	ActiveRoutes int32 `protobuf:"varint,8,opt,name=active_routes,json=activeRoutes,proto3" json:"active_routes,omitempty"`
	// Legs is the per-route breakdown for this sample interval. One
	// entry per established route, in route-index order. Additive to
	// the aggregate fields above: consumers measuring adaptive routing
	// policies read per-leg bandwidth + identity over time from here,
	// while consumers wanting only the total keep using the aggregate
	// fields. Empty on runs where no route came up.
	Legs []*MuxLegSample `protobuf:"bytes,9,rep,name=legs,proto3" json:"legs,omitempty"`
	// contains filtered or unexported fields
}

type MuxLegLifecycle struct {

	// Event is one of "added", "dropped", "promoted", "demoted".
	Event string `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"`
	// RouteIndex is the affected leg's index at the time of the event.
	RouteIndex int32 `protobuf:"varint,2,opt,name=route_index,json=routeIndex,proto3" json:"route_index,omitempty"`
	// GateState is the leg's resulting warm-standby gate state: "active"
	// (selected for pumping) or "standby" (kept alive via keepalive but not
	// pumped). Mirrors router.LegInfo.Standby observed by the on_tick ABI.
	GateState string `protobuf:"bytes,3,opt,name=gate_state,json=gateState,proto3" json:"gate_state,omitempty"`
	// IntermediatePk / TransportKind identify the affected leg's path — same
	// fields as MuxLegSample so a consumer can join the event to the series.
	IntermediatePk string `protobuf:"bytes,4,opt,name=intermediate_pk,json=intermediatePk,proto3" json:"intermediate_pk,omitempty"`
	TransportKind  string `protobuf:"bytes,5,opt,name=transport_kind,json=transportKind,proto3" json:"transport_kind,omitempty"`
	// ElapsedNs is time since pump-start when the mutation was applied. Same
	// epoch as MuxBandwidthSample.ElapsedNs.
	ElapsedNs int64 `protobuf:"varint,6,opt,name=elapsed_ns,json=elapsedNs,proto3" json:"elapsed_ns,omitempty"`
	// contains filtered or unexported fields
}

type MuxLegSample struct {

	// RouteIndex is the same 0..Routes-1 index from the matching
	// MuxRouteEstablished event, letting consumers join a leg's
	// per-sample series back to its established path.
	RouteIndex int32 `protobuf:"varint,1,opt,name=route_index,json=routeIndex,proto3" json:"route_index,omitempty"`
	// IntermediatePk is the first hop's `to` PK — the leg's
	// distinguishing intermediate. Empty when the route is direct
	// (single hop straight to the target, no intermediate).
	IntermediatePk string `protobuf:"bytes,2,opt,name=intermediate_pk,json=intermediatePk,proto3" json:"intermediate_pk,omitempty"`
	// TransportKind is the first hop's transport type (stcpr, sudph,
	// dmsg, ...). Lets consumers correlate per-leg throughput with the
	// carrier the leg egresses on.
	TransportKind string `protobuf:"bytes,3,opt,name=transport_kind,json=transportKind,proto3" json:"transport_kind,omitempty"`
	// BytesSent / BytesRecv are cumulative for this leg since pump
	// start (NOT since the last sample) — same epoch as the aggregate
	// MuxBandwidthSample.BytesSent.
	BytesSent int64 `protobuf:"varint,4,opt,name=bytes_sent,json=bytesSent,proto3" json:"bytes_sent,omitempty"`
	BytesRecv int64 `protobuf:"varint,5,opt,name=bytes_recv,json=bytesRecv,proto3" json:"bytes_recv,omitempty"`
	// InstSendBps / InstRecvBps are this leg's per-interval rates
	// (delta since the previous sample), in bits-per-second — mirrors
	// how MuxBandwidthSample.InstantSendBps is computed for the
	// aggregate.
	InstSendBps float64 `protobuf:"fixed64,6,opt,name=inst_send_bps,json=instSendBps,proto3" json:"inst_send_bps,omitempty"`
	InstRecvBps float64 `protobuf:"fixed64,7,opt,name=inst_recv_bps,json=instRecvBps,proto3" json:"inst_recv_bps,omitempty"`
	// Alive is the route's not-failed state — true while the leg's
	// pump goroutine is still running. Matches the accounting behind
	// MuxBandwidthSample.ActiveRoutes.
	Alive bool `protobuf:"varint,8,opt,name=alive,proto3" json:"alive,omitempty"`
	// LatencyMs is the leg's EWMA-smoothed round-trip latency in
	// milliseconds, sampled by the per-leg policy probe. 0 = unknown (no
	// measurement yet). Only populated on policy-driven runs — the pure
	// baseline uses a single dedicated probe route, not per-leg probes.
	// This is the signal latency-adaptive / adaptive presets evict on.
	LatencyMs int32 `protobuf:"varint,9,opt,name=latency_ms,json=latencyMs,proto3" json:"latency_ms,omitempty"`
	// Standby is the leg's warm-standby gate state: true when the policy
	// demoted this leg (kept alive via keepalive, not pumped). Lets the
	// telemetry consumer see the gate flip in the per-sample series, not
	// just at the lifecycle event.
	Standby bool `protobuf:"varint,10,opt,name=standby,proto3" json:"standby,omitempty"`
	// contains filtered or unexported fields
}

type MuxRouteEstablished struct {

	// RouteIndex is 0..Routes-1, assigned in setup-order.
	RouteIndex int32 `protobuf:"varint,1,opt,name=route_index,json=routeIndex,proto3" json:"route_index,omitempty"`
	// SetupLatencyNs is the time spent on the route-setup phase
	// (route-finder query + setup-node negotiation + handshake).
	SetupLatencyNs int64 `protobuf:"varint,2,opt,name=setup_latency_ns,json=setupLatencyNs,proto3" json:"setup_latency_ns,omitempty"`
	// Hops is the chosen path. Consumers verify min_hops by
	// counting (len(hops) - 1) intermediate edges.
	Hops []*RouteHop `protobuf:"bytes,3,rep,name=hops,proto3" json:"hops,omitempty"`
	// Failed is set when the route could not be established;
	// SetupErr carries the cause. The route is excluded from the
	// pump phase but kept in the event log for diagnostics.
	Failed   bool   `protobuf:"varint,4,opt,name=failed,proto3" json:"failed,omitempty"`
	SetupErr string `protobuf:"bytes,5,opt,name=setup_err,json=setupErr,proto3" json:"setup_err,omitempty"`
	// contains filtered or unexported fields
}

type MuxRouteFailure struct {

	// RouteIndex is the same 0..Routes-1 index from the matching
	// MuxRouteEstablished event.
	RouteIndex int32 `protobuf:"varint,1,opt,name=route_index,json=routeIndex,proto3" json:"route_index,omitempty"`
	// ErrorMessage is the formatted error returned by the pump call.
	ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	// BytesSentBeforeFailure / BytesReceivedBeforeFailure are the
	// cumulative bytes the route had pumped up to the failure point.
	// Zero is meaningful — indicates the first call after route
	// establishment failed before any bytes shipped.
	BytesSentBeforeFailure     uint64 `` /* 132-byte string literal not displayed */
	BytesReceivedBeforeFailure uint64 `` /* 144-byte string literal not displayed */
	// ElapsedNs is time since pump-start when the failure happened.
	// Same epoch as MuxBandwidthSample.ElapsedNs.
	ElapsedNs int64 `protobuf:"varint,5,opt,name=elapsed_ns,json=elapsedNs,proto3" json:"elapsed_ns,omitempty"`
	// contains filtered or unexported fields
}

type MuxRttProbe struct {

	// Sequence is the 1-indexed probe number, in emit order.
	Sequence int64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
	// LatencyNs is the measured RTT. 0 when the probe failed; Error
	// carries the cause.
	LatencyNs int64  `protobuf:"varint,2,opt,name=latency_ns,json=latencyNs,proto3" json:"latency_ns,omitempty"`
	Error     string `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	// ElapsedNs is the time since the first byte was sent (same epoch
	// as MuxBandwidthSample.ElapsedNs). Lets consumers align probes
	// with concurrent bandwidth samples without timestamp diffing.
	ElapsedNs int64 `protobuf:"varint,4,opt,name=elapsed_ns,json=elapsedNs,proto3" json:"elapsed_ns,omitempty"`
	// contains filtered or unexported fields
}

type NetworkStat struct {
	BytesSent     uint64  `protobuf:"varint,1,opt,name=bytes_sent,json=bytesSent,proto3" json:"bytes_sent,omitempty"`                // Total bytes sent
	BytesRecv     uint64  `protobuf:"varint,2,opt,name=bytes_recv,json=bytesRecv,proto3" json:"bytes_recv,omitempty"`                // Total bytes received
	PacketsSent   uint64  `protobuf:"varint,3,opt,name=packets_sent,json=packetsSent,proto3" json:"packets_sent,omitempty"`          // Total packets sent
	PacketsRecv   uint64  `protobuf:"varint,4,opt,name=packets_recv,json=packetsRecv,proto3" json:"packets_recv,omitempty"`          // Total packets received
	BytesSentRate float64 `protobuf:"fixed64,5,opt,name=bytes_sent_rate,json=bytesSentRate,proto3" json:"bytes_sent_rate,omitempty"` // Bytes sent per second (since last update)
	BytesRecvRate float64 `protobuf:"fixed64,6,opt,name=bytes_recv_rate,json=bytesRecvRate,proto3" json:"bytes_recv_rate,omitempty"` // Bytes received per second (since last update)
	// contains filtered or unexported fields
}

type PingClient struct {
	// contains filtered or unexported fields
}

type PingConf struct {
	PK          cipher.PubKey
	Tries       int
	PcktSize    int
	LocalRoute  bool
	TransportID string         // Optional: use specific transport (skips route calculation)
	ForwardHops []RouteHopInfo // Optional: explicit forward route (skips route calculation)
	ReverseHops []RouteHopInfo // Optional: explicit reverse route (skips route calculation)
	// RouteIndex selects among N parallel routes to the same peer.
	// Zero = primary / single-route (legacy behavior). Mirrors
	// visor.PingConfig.RouteIndex; the adapter passes it through.
	RouteIndex int
	// MinHops is the per-call route-finder min-hops constraint.
	// Mirrors visor.PingConfig.MinHops; adapter passes it through.
	// 0 = inherit visor-global routing.min_hops.
	MinHops int
	// SetupTimeoutNs is the dial-setup ceiling in nanoseconds.
	// Mirrors visor.PingConfig.SetupTimeout; adapter converts to
	// time.Duration. 0 falls back to DialPing's 30s default.
	SetupTimeoutNs int64
	// Timeout bounds a single PingOnce round-trip. Mirrors
	// visor.PingConfig.Timeout; 0 = the visor-side 10s default. The
	// mux-bw probe loop sets it to the remaining measurement window.
	Timeout time.Duration
}

type PingRequest struct {
	PublicKey      string      `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`                   // Target visor public key
	Tries          int32       `protobuf:"varint,2,opt,name=tries,proto3" json:"tries,omitempty"`                                           // Number of ping attempts
	PacketSizeKb   int32       `protobuf:"varint,3,opt,name=packet_size_kb,json=packetSizeKb,proto3" json:"packet_size_kb,omitempty"`       // Packet size in KB
	LocalRoute     bool        `protobuf:"varint,4,opt,name=local_route,json=localRoute,proto3" json:"local_route,omitempty"`               // Use local route calculation
	PingTimeoutNs  int64       `protobuf:"varint,5,opt,name=ping_timeout_ns,json=pingTimeoutNs,proto3" json:"ping_timeout_ns,omitempty"`    // Timeout for ping phase only (after route setup), 0 = no timeout
	SetupTimeoutNs int64       `protobuf:"varint,6,opt,name=setup_timeout_ns,json=setupTimeoutNs,proto3" json:"setup_timeout_ns,omitempty"` // Timeout for route setup phase, 0 = no timeout (default 30s recommended)
	DmsgServerPk   string      `protobuf:"bytes,7,opt,name=dmsg_server_pk,json=dmsgServerPk,proto3" json:"dmsg_server_pk,omitempty"`        // Optional: specific DMSG server to use for DMSG pings
	TransportId    string      `protobuf:"bytes,8,opt,name=transport_id,json=transportId,proto3" json:"transport_id,omitempty"`             // Optional: use specific transport (skips route calculation)
	ForwardHops    []*RouteHop `protobuf:"bytes,9,rep,name=forward_hops,json=forwardHops,proto3" json:"forward_hops,omitempty"`             // Optional: explicit forward route (skips route calculation)
	ReverseHops    []*RouteHop `protobuf:"bytes,10,rep,name=reverse_hops,json=reverseHops,proto3" json:"reverse_hops,omitempty"`            // Optional: explicit reverse route (skips route calculation)
	// contains filtered or unexported fields
}

type PingResult struct {
	Sequence        int32       `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`                                          // Ping sequence number (1-indexed)
	LatencyNs       int64       `protobuf:"varint,2,opt,name=latency_ns,json=latencyNs,proto3" json:"latency_ns,omitempty"`                       // Round-trip time in nanoseconds
	Error           string      `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`                                                 // Error message if ping failed
	IsSetup         bool        `protobuf:"varint,4,opt,name=is_setup,json=isSetup,proto3" json:"is_setup,omitempty"`                             // True if this is the route setup time, not a ping
	RouteHops       []string    `protobuf:"bytes,5,rep,name=route_hops,json=routeHops,proto3" json:"route_hops,omitempty"`                        // Route hops (public keys), only set for setup message (deprecated)
	RouteHopDetails []*RouteHop `protobuf:"bytes,6,rep,name=route_hop_details,json=routeHopDetails,proto3" json:"route_hop_details,omitempty"`    // Detailed route hops with transport info
	DmsgServerPk    string      `protobuf:"bytes,7,opt,name=dmsg_server_pk,json=dmsgServerPk,proto3" json:"dmsg_server_pk,omitempty"`             // For DMSG pings: the server PK used for this connection
	RouteCalcTimeNs int64       `protobuf:"varint,8,opt,name=route_calc_time_ns,json=routeCalcTimeNs,proto3" json:"route_calc_time_ns,omitempty"` // Route calculation time in nanoseconds (local route mode only)
	// contains filtered or unexported fields
}

type PingResultCallback func(seq int32, latency time.Duration, isSetup bool, routeHopDetails []RouteHopDetail, dmsgServerPK string, routeCalcTime time.Duration, err error)

type PingRouteRef struct {
	PK    cipher.PubKey
	Index int
}

type PingServer struct {
	UnimplementedPingServiceServer
	// contains filtered or unexported fields
}

type PingServiceClient interface {
	// StreamPing performs multiple pings and streams results back one at a time
	StreamPing(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[PingResult], error)
	// StreamDmsgPing performs multiple pings over dmsg and streams results
	StreamDmsgPing(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[PingResult], error)
	// StreamBandwidthTest performs a bandwidth test and streams progress
	StreamBandwidthTest(ctx context.Context, in *BandwidthRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[BandwidthProgress], error)
	// StreamDmsgBandwidthTest performs a bandwidth test over dmsg and streams progress
	StreamDmsgBandwidthTest(ctx context.Context, in *BandwidthRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[BandwidthProgress], error)
	// GetRemoteDmsgServers returns the DMSG servers a remote visor is connected to
	GetRemoteDmsgServers(ctx context.Context, in *DmsgServersRequest, opts ...grpc.CallOption) (*DmsgServersResponse, error)
	// StreamSystemStats streams system stats (CPU, memory, disk, network, etc.) for gotop-style monitoring
	StreamSystemStats(ctx context.Context, in *SystemStatsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SystemStats], error)
	// GetSystemStats returns a single snapshot of system stats
	GetSystemStats(ctx context.Context, in *SystemStatsRequest, opts ...grpc.CallOption) (*SystemStats, error)
	// StreamRemoteSystemStats proxies system stats from a remote visor via DMSG
	// The local visor dials the remote visor over DMSG and forwards the stats stream
	StreamRemoteSystemStats(ctx context.Context, in *RemoteSystemStatsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SystemStats], error)
	// StreamAppLogs streams visor log entries scoped to one app's session.
	// Used by 'skywire-cli proxy start --verbose' to surface what the visor is
	// doing while spinning up an app's transports/routes.
	StreamAppLogs(ctx context.Context, in *AppLogStreamRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[AppLogEntry], error)
	// StreamCalcRoutes runs a route-finder BFS server-side and streams each
	// valid route back as it's discovered. Lets the CLI display routes
	// incrementally and avoids accumulating every result in memory before
	// returning — important when count is large or unbounded.
	StreamCalcRoutes(ctx context.Context, in *CalcRoutesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CalcRoute], error)
	// StreamGroupMessages opens a long-lived stream of inbound group
	// messages. The server holds a per-stream subscription to the
	// visor's group inbox and pushes each delivered message to the
	// client as it arrives. Replaces the net/rpc poll loop in
	// 'cli skychat group listen', which would lose its underlying
	// connection every 5 minutes to the per-conn deadline applied at
	// init_apps.go for unary-RPC hang detection. Stream lifetime is
	// the listen lifetime, no arbitrary ceiling.
	StreamGroupMessages(ctx context.Context, in *GroupMessagesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GroupMessageEvent], error)
	// StreamPingTree walks the visor's neighborhood breadth-first and
	// streams discovery + ping events as they happen. Replaces the
	// client-side BFS in 'cli visor ping tree' — server-side has
	// direct access to TransportSummary.LatencyMS (the smoothed per-
	// transport RTT measured continuously by the transport layer),
	// the route-finder, and the local tpM, so it can:
	//   - Skip live pings at level 1 when the transport already has a
	//     warmed latency cache (use_transport_latency flag);
	//   - Walk tpM.WalkTransports directly without the snapshot
	//     allocation cost that the unary Transports() RPC imposes
	//     on visors with hundreds of transports;
	//   - Observe cancellation at every BFS iteration so a client
	//     disconnect tears down the walk within one in-flight ping.
	//
	// Result events arrive in chunk-complete-by-completion order, NOT
	// deterministically grouped per peer — consumers that want
	// (level, parent_pk, remote_pk) grouping must sort/bucket on
	// receive. Server-side per-level concurrency means events for
	// level N+1 never appear before level N's LevelDone.
	//
	// Authorization: the handler gates on the same whitelist used by
	// dmsgscp (hypervisors + own PK + Dmsgpty.Whitelist). On a public
	// visor with hundreds of transports, an unauthenticated caller
	// could trigger a many-target ping storm; the gate prevents that.
	StreamPingTree(ctx context.Context, in *PingTreeRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[PingTreeEvent], error)
	// StreamMuxBandwidth measures bandwidth + queueing-delay between
	// this visor and a target peer, optionally across N parallel
	// routes. The operator-visible hypothesis: routes that EXCLUDE the
	// direct transport (via min_hops >= 2) should sum to MORE bandwidth
	// than the direct edge alone, because intermediates aggregate
	// independent paths. This RPC produces the data to test that.
	//
	// Three flavors via the request fields:
	//   - routes=1, min_hops=0: baseline — whatever route the finder
	//     picks. With a healthy direct transport this measures the
	//     direct edge.
	//   - routes=1, min_hops=2: single non-direct path — forces the
	//     route through at least one intermediate.
	//   - routes=N, min_hops=>=0: N parallel routes pumping bytes
	//     concurrently. Aggregate throughput is the operator's headline
	//     comparison metric.
	//
	// Optionally a separate small-packet probe runs alongside the bulk
	// load to capture queueing-delay: loaded RTT vs unloaded RTT
	// baseline. The probe rides the SAME first route as the bulk pump,
	// so the queueing-delay number reflects that route's saturation.
	//
	// Wire shape mirrors StreamPingTree: server-side BFS becomes
	// server-side bandwidth-pump, events stream as they happen,
	// ctx.Done() at every iteration, bounded internal channel.
	StreamMuxBandwidth(ctx context.Context, in *MuxBandwidthRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[MuxBandwidthEvent], error)
	// StreamRouteGroupMuxInfo streams a running app's per-leg mux
	// telemetry on a fixed cadence — the server-streaming equivalent of
	// the unary RouteGroupMuxInfo net/rpc call that 'cli proxy mux plot'
	// (default, watch-a-running-app mode) polls. Lets that plot update
	// smoothly/continuously like the --pk StreamMuxBandwidth path,
	// instead of the choppy 1 Hz unary gob poll. Each sample carries the
	// same []visor.MuxRouteGroupInfo per-leg breakdown the unary RPC
	// returns. The handler never errors the stream on a transient absent
	// route group — it emits an empty sample and keeps sampling, so the
	// plot renders an empty frame until the app dials.
	StreamRouteGroupMuxInfo(ctx context.Context, in *StreamRouteGroupMuxInfoRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[RouteGroupMuxInfoSample], error)
}

type PingServiceServer interface {
	// StreamPing performs multiple pings and streams results back one at a time
	StreamPing(*PingRequest, grpc.ServerStreamingServer[PingResult]) error
	// StreamDmsgPing performs multiple pings over dmsg and streams results
	StreamDmsgPing(*PingRequest, grpc.ServerStreamingServer[PingResult]) error
	// StreamBandwidthTest performs a bandwidth test and streams progress
	StreamBandwidthTest(*BandwidthRequest, grpc.ServerStreamingServer[BandwidthProgress]) error
	// StreamDmsgBandwidthTest performs a bandwidth test over dmsg and streams progress
	StreamDmsgBandwidthTest(*BandwidthRequest, grpc.ServerStreamingServer[BandwidthProgress]) error
	// GetRemoteDmsgServers returns the DMSG servers a remote visor is connected to
	GetRemoteDmsgServers(context.Context, *DmsgServersRequest) (*DmsgServersResponse, error)
	// StreamSystemStats streams system stats (CPU, memory, disk, network, etc.) for gotop-style monitoring
	StreamSystemStats(*SystemStatsRequest, grpc.ServerStreamingServer[SystemStats]) error
	// GetSystemStats returns a single snapshot of system stats
	GetSystemStats(context.Context, *SystemStatsRequest) (*SystemStats, error)
	// StreamRemoteSystemStats proxies system stats from a remote visor via DMSG
	// The local visor dials the remote visor over DMSG and forwards the stats stream
	StreamRemoteSystemStats(*RemoteSystemStatsRequest, grpc.ServerStreamingServer[SystemStats]) error
	// StreamAppLogs streams visor log entries scoped to one app's session.
	// Used by 'skywire-cli proxy start --verbose' to surface what the visor is
	// doing while spinning up an app's transports/routes.
	StreamAppLogs(*AppLogStreamRequest, grpc.ServerStreamingServer[AppLogEntry]) error
	// StreamCalcRoutes runs a route-finder BFS server-side and streams each
	// valid route back as it's discovered. Lets the CLI display routes
	// incrementally and avoids accumulating every result in memory before
	// returning — important when count is large or unbounded.
	StreamCalcRoutes(*CalcRoutesRequest, grpc.ServerStreamingServer[CalcRoute]) error
	// StreamGroupMessages opens a long-lived stream of inbound group
	// messages. The server holds a per-stream subscription to the
	// visor's group inbox and pushes each delivered message to the
	// client as it arrives. Replaces the net/rpc poll loop in
	// 'cli skychat group listen', which would lose its underlying
	// connection every 5 minutes to the per-conn deadline applied at
	// init_apps.go for unary-RPC hang detection. Stream lifetime is
	// the listen lifetime, no arbitrary ceiling.
	StreamGroupMessages(*GroupMessagesRequest, grpc.ServerStreamingServer[GroupMessageEvent]) error
	// StreamPingTree walks the visor's neighborhood breadth-first and
	// streams discovery + ping events as they happen. Replaces the
	// client-side BFS in 'cli visor ping tree' — server-side has
	// direct access to TransportSummary.LatencyMS (the smoothed per-
	// transport RTT measured continuously by the transport layer),
	// the route-finder, and the local tpM, so it can:
	//   - Skip live pings at level 1 when the transport already has a
	//     warmed latency cache (use_transport_latency flag);
	//   - Walk tpM.WalkTransports directly without the snapshot
	//     allocation cost that the unary Transports() RPC imposes
	//     on visors with hundreds of transports;
	//   - Observe cancellation at every BFS iteration so a client
	//     disconnect tears down the walk within one in-flight ping.
	//
	// Result events arrive in chunk-complete-by-completion order, NOT
	// deterministically grouped per peer — consumers that want
	// (level, parent_pk, remote_pk) grouping must sort/bucket on
	// receive. Server-side per-level concurrency means events for
	// level N+1 never appear before level N's LevelDone.
	//
	// Authorization: the handler gates on the same whitelist used by
	// dmsgscp (hypervisors + own PK + Dmsgpty.Whitelist). On a public
	// visor with hundreds of transports, an unauthenticated caller
	// could trigger a many-target ping storm; the gate prevents that.
	StreamPingTree(*PingTreeRequest, grpc.ServerStreamingServer[PingTreeEvent]) error
	// StreamMuxBandwidth measures bandwidth + queueing-delay between
	// this visor and a target peer, optionally across N parallel
	// routes. The operator-visible hypothesis: routes that EXCLUDE the
	// direct transport (via min_hops >= 2) should sum to MORE bandwidth
	// than the direct edge alone, because intermediates aggregate
	// independent paths. This RPC produces the data to test that.
	//
	// Three flavors via the request fields:
	//   - routes=1, min_hops=0: baseline — whatever route the finder
	//     picks. With a healthy direct transport this measures the
	//     direct edge.
	//   - routes=1, min_hops=2: single non-direct path — forces the
	//     route through at least one intermediate.
	//   - routes=N, min_hops=>=0: N parallel routes pumping bytes
	//     concurrently. Aggregate throughput is the operator's headline
	//     comparison metric.
	//
	// Optionally a separate small-packet probe runs alongside the bulk
	// load to capture queueing-delay: loaded RTT vs unloaded RTT
	// baseline. The probe rides the SAME first route as the bulk pump,
	// so the queueing-delay number reflects that route's saturation.
	//
	// Wire shape mirrors StreamPingTree: server-side BFS becomes
	// server-side bandwidth-pump, events stream as they happen,
	// ctx.Done() at every iteration, bounded internal channel.
	StreamMuxBandwidth(*MuxBandwidthRequest, grpc.ServerStreamingServer[MuxBandwidthEvent]) error
	// StreamRouteGroupMuxInfo streams a running app's per-leg mux
	// telemetry on a fixed cadence — the server-streaming equivalent of
	// the unary RouteGroupMuxInfo net/rpc call that 'cli proxy mux plot'
	// (default, watch-a-running-app mode) polls. Lets that plot update
	// smoothly/continuously like the --pk StreamMuxBandwidth path,
	// instead of the choppy 1 Hz unary gob poll. Each sample carries the
	// same []visor.MuxRouteGroupInfo per-leg breakdown the unary RPC
	// returns. The handler never errors the stream on a transient absent
	// route group — it emits an empty sample and keeps sampling, so the
	// plot renders an empty frame until the app dials.
	StreamRouteGroupMuxInfo(*StreamRouteGroupMuxInfoRequest, grpc.ServerStreamingServer[RouteGroupMuxInfoSample]) error
	// contains filtered or unexported methods
}

type PingService_StreamAppLogsClient = grpc.ServerStreamingClient[AppLogEntry]

type PingService_StreamAppLogsServer = grpc.ServerStreamingServer[AppLogEntry]

type PingService_StreamBandwidthTestClient = grpc.ServerStreamingClient[BandwidthProgress]

type PingService_StreamBandwidthTestServer = grpc.ServerStreamingServer[BandwidthProgress]

type PingService_StreamCalcRoutesClient = grpc.ServerStreamingClient[CalcRoute]

type PingService_StreamCalcRoutesServer = grpc.ServerStreamingServer[CalcRoute]

type PingService_StreamDmsgBandwidthTestClient = grpc.ServerStreamingClient[BandwidthProgress]

type PingService_StreamDmsgBandwidthTestServer = grpc.ServerStreamingServer[BandwidthProgress]

type PingService_StreamDmsgPingClient = grpc.ServerStreamingClient[PingResult]

type PingService_StreamDmsgPingServer = grpc.ServerStreamingServer[PingResult]

type PingService_StreamGroupMessagesClient = grpc.ServerStreamingClient[GroupMessageEvent]

type PingService_StreamGroupMessagesServer = grpc.ServerStreamingServer[GroupMessageEvent]

type PingService_StreamMuxBandwidthClient = grpc.ServerStreamingClient[MuxBandwidthEvent]

type PingService_StreamMuxBandwidthServer = grpc.ServerStreamingServer[MuxBandwidthEvent]

type PingService_StreamPingClient = grpc.ServerStreamingClient[PingResult]

type PingService_StreamPingServer = grpc.ServerStreamingServer[PingResult]

type PingService_StreamPingTreeClient = grpc.ServerStreamingClient[PingTreeEvent]

type PingService_StreamPingTreeServer = grpc.ServerStreamingServer[PingTreeEvent]

type PingService_StreamRemoteSystemStatsClient = grpc.ServerStreamingClient[SystemStats]

type PingService_StreamRemoteSystemStatsServer = grpc.ServerStreamingServer[SystemStats]

type PingService_StreamRouteGroupMuxInfoClient = grpc.ServerStreamingClient[RouteGroupMuxInfoSample]

type PingService_StreamRouteGroupMuxInfoServer = grpc.ServerStreamingServer[RouteGroupMuxInfoSample]

type PingService_StreamSystemStatsClient = grpc.ServerStreamingClient[SystemStats]

type PingService_StreamSystemStatsServer = grpc.ServerStreamingServer[SystemStats]

type PingTreeDiscovered struct {
	TpId     string `protobuf:"bytes,1,opt,name=tp_id,json=tpId,proto3" json:"tp_id,omitempty"`
	TpType   string `protobuf:"bytes,2,opt,name=tp_type,json=tpType,proto3" json:"tp_type,omitempty"`
	RemotePk string `protobuf:"bytes,3,opt,name=remote_pk,json=remotePk,proto3" json:"remote_pk,omitempty"`
	ParentPk string `protobuf:"bytes,4,opt,name=parent_pk,json=parentPk,proto3" json:"parent_pk,omitempty"`
	Level    int32  `protobuf:"varint,5,opt,name=level,proto3" json:"level,omitempty"`
	// contains filtered or unexported fields
}

type PingTreeEvent struct {
	TimestampNs int64 `protobuf:"varint,1,opt,name=timestamp_ns,json=timestampNs,proto3" json:"timestamp_ns,omitempty"`
	// Types that are valid to be assigned to Payload:
	//
	//	*PingTreeEvent_Discovered
	//	*PingTreeEvent_PingResult
	//	*PingTreeEvent_LevelDone
	//	*PingTreeEvent_RunDone
	//	*PingTreeEvent_StatusUpdate
	//	*PingTreeEvent_ServerError
	Payload isPingTreeEvent_Payload `protobuf_oneof:"payload"`
	// contains filtered or unexported fields
}

type PingTreeEvent_Discovered struct {
	Discovered *PingTreeDiscovered `protobuf:"bytes,10,opt,name=discovered,proto3,oneof"`
}

type PingTreeEvent_LevelDone struct {
	LevelDone *PingTreeLevelDone `protobuf:"bytes,12,opt,name=level_done,json=levelDone,proto3,oneof"`
}

type PingTreeEvent_PingResult struct {
	PingResult *PingTreeResult `protobuf:"bytes,11,opt,name=ping_result,json=pingResult,proto3,oneof"`
}

type PingTreeEvent_RunDone struct {
	RunDone *PingTreeRunDone `protobuf:"bytes,13,opt,name=run_done,json=runDone,proto3,oneof"`
}

type PingTreeEvent_ServerError struct {
	// ServerError is a terminal event: the handler is about to
	// close the stream because of an unrecoverable condition
	// (e.g. proto break, internal panic recovered). Clients should
	// treat receipt as equivalent to stream-EOF with a known cause.
	ServerError *PingTreeServerError `protobuf:"bytes,15,opt,name=server_error,json=serverError,proto3,oneof"`
}

type PingTreeEvent_StatusUpdate struct {
	StatusUpdate *PingTreeStatusUpdate `protobuf:"bytes,14,opt,name=status_update,json=statusUpdate,proto3,oneof"`
}

type PingTreeLevelDone struct {
	Level int32 `protobuf:"varint,1,opt,name=level,proto3" json:"level,omitempty"`
	// Attempted = sum of (succeeded + failed + skipped_cached + skipped_dry).
	Attempted int32 `protobuf:"varint,2,opt,name=attempted,proto3" json:"attempted,omitempty"`
	Succeeded int32 `protobuf:"varint,3,opt,name=succeeded,proto3" json:"succeeded,omitempty"`
	Failed    int32 `protobuf:"varint,4,opt,name=failed,proto3" json:"failed,omitempty"`
	// SkippedCached is the count of entries where the
	// use_transport_latency fast-path fired. Lets harnesses compute
	// cache hit rate.
	SkippedCached int32 `protobuf:"varint,5,opt,name=skipped_cached,json=skippedCached,proto3" json:"skipped_cached,omitempty"`
	// contains filtered or unexported fields
}

type PingTreeRequest struct {

	// MaxLevel caps BFS depth. 0 = unlimited until expansion exhausts.
	MaxLevel int32 `protobuf:"varint,1,opt,name=max_level,json=maxLevel,proto3" json:"max_level,omitempty"`
	// Hops, when > 0, pings ONLY entries at exactly N hops. The BFS
	// still discovers intermediate levels (so it can reach the target),
	// but no PingResult fires for non-target levels. Synth's "latency
	// as a function of hop count" measurement uses this.
	Hops int32 `protobuf:"varint,2,opt,name=hops,proto3" json:"hops,omitempty"`
	// Tries is the per-transport ping count. The PingResult carries
	// the aggregated stats (avg, p50, p99, jitter) over all tries.
	// 0 falls back to 1.
	Tries int32 `protobuf:"varint,3,opt,name=tries,proto3" json:"tries,omitempty"`
	// PacketSizeKb is the per-ping packet size. 0 falls back to 2 KB.
	PacketSizeKb int32 `protobuf:"varint,4,opt,name=packet_size_kb,json=packetSizeKb,proto3" json:"packet_size_kb,omitempty"`
	// PingTimeoutNs bounds each individual ping (after route setup).
	// 0 falls back to 30s.
	PingTimeoutNs int64 `protobuf:"varint,5,opt,name=ping_timeout_ns,json=pingTimeoutNs,proto3" json:"ping_timeout_ns,omitempty"`
	// SetupTimeoutNs bounds the route-setup phase per transport.
	// 0 falls back to 30s.
	SetupTimeoutNs int64 `protobuf:"varint,6,opt,name=setup_timeout_ns,json=setupTimeoutNs,proto3" json:"setup_timeout_ns,omitempty"`
	// Concurrency limits in-flight pings per level. The cap resets
	// between levels (level 2 starts with a fresh budget after level 1
	// drains) — predictable LevelDone semantics + bounded fan-out at
	// deep levels. 0 falls back to 16.
	Concurrency int32 `protobuf:"varint,7,opt,name=concurrency,proto3" json:"concurrency,omitempty"`
	// OnlineOnly filters discovered visors via the uptime tracker.
	OnlineOnly bool `protobuf:"varint,8,opt,name=online_only,json=onlineOnly,proto3" json:"online_only,omitempty"`
	// MinVersion filters by minimum visor version (semver). Empty = no
	// filter.
	MinVersion string `protobuf:"bytes,9,opt,name=min_version,json=minVersion,proto3" json:"min_version,omitempty"`
	// UseTransportLatency turns on the level-1 fast path: when a
	// direct transport already has a non-zero smoothed
	// TransportSummary.LatencyMS, the handler emits a PingResult with
	// latency_source="transport_summary" and skips the live ping.
	// Saves traffic + makes level 1 instant for warm transports.
	// Deeper levels always live-ping (no transport-level latency for
	// multi-hop routes).
	UseTransportLatency bool `protobuf:"varint,10,opt,name=use_transport_latency,json=useTransportLatency,proto3" json:"use_transport_latency,omitempty"`
	// DmsgOnly forces the ping to ride the DMSG path instead of the
	// skywire router. Mirrors `cli visor ping --dmsg`.
	DmsgOnly bool `protobuf:"varint,11,opt,name=dmsg_only,json=dmsgOnly,proto3" json:"dmsg_only,omitempty"`
	// DmsgPreCheck probes DMSG reachability before attempting a
	// route ping. Discards unreachable visors early.
	DmsgPreCheck bool `protobuf:"varint,12,opt,name=dmsg_pre_check,json=dmsgPreCheck,proto3" json:"dmsg_pre_check,omitempty"`
	// Retries adds N retry attempts on failed pings. 0 = no retry.
	Retries int32 `protobuf:"varint,13,opt,name=retries,proto3" json:"retries,omitempty"`
	// DryRun runs the BFS discovery but emits no PingResult events;
	// useful for visualizing the reachable graph without traffic.
	DryRun bool `protobuf:"varint,14,opt,name=dry_run,json=dryRun,proto3" json:"dry_run,omitempty"`
	// contains filtered or unexported fields
}