@miradorlabs/web-grpc 2.30.0 → 2.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miradorlabs/web-grpc",
-  "version": "2.30.0",
+  "version": "2.32.0",
   "description": "Generated gRPC (grpc-js) client stubs for the Mirador web gateway.",
   "main": "index.js",
   "types": "index.d.ts",

package/proto/gateway/web/v1/metric_gateway.ts

@@ -503,6 +503,48 @@ export interface WidgetQueryError {
   message: string;
 }
 
+export interface StreamDashboardPreviewsRequest {
+  /** Verified against the caller's identity before proxying. */
+  organizationId: string;
+  projectId: string;
+  /**
+   * The boards in/near the viewport: 1–64 dashboard UUIDs, de-duplicated. An
+   * unknown or foreign id yields an in-band error frame, not a failed stream.
+   */
+  dashboardIds: string[];
+}
+
+export interface DashboardPreviewEnvelope {
+  dashboardId: string;
+  manifest?: DashboardPreviewManifest | undefined;
+  queryResult?:
+    | DashboardPreviewQueryResult
+    | undefined;
+  /** Fatal for THIS dashboard only (e.g. not found); the batch continues. */
+  error?: DashboardPreviewError | undefined;
+}
+
+/**
+ * DashboardPreviewManifest is the widget set the card should render, chosen
+ * server-side. time_window / time_interval are cleared: they do NOT apply to the
+ * preview data. Read the QuerySnapshot bounds, never the widget pins.
+ */
+export interface DashboardPreviewManifest {
+  widgets: Widget[];
+  dashboardVersion: number;
+}
+
+export interface DashboardPreviewQueryResult {
+  widgetId: string;
+  queryIndex: number;
+  snapshot?: QuerySnapshot | undefined;
+  error?: WidgetQueryError | undefined;
+}
+
+export interface DashboardPreviewError {
+  message: string;
+}
+
 function createBaseStreamMetricsRequest(): StreamMetricsRequest {
   return { organizationId: "", projectId: "" };
 }
@@ -4268,6 +4310,492 @@ export const WidgetQueryError: MessageFns<WidgetQueryError> = {
   },
 };
 
+function createBaseStreamDashboardPreviewsRequest(): StreamDashboardPreviewsRequest {
+  return { organizationId: "", projectId: "", dashboardIds: [] };
+}
+
+export const StreamDashboardPreviewsRequest: MessageFns<StreamDashboardPreviewsRequest> = {
+  encode(message: StreamDashboardPreviewsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.organizationId !== "") {
+      writer.uint32(10).string(message.organizationId);
+    }
+    if (message.projectId !== "") {
+      writer.uint32(18).string(message.projectId);
+    }
+    for (const v of message.dashboardIds) {
+      writer.uint32(26).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): StreamDashboardPreviewsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStreamDashboardPreviewsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.organizationId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.projectId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.dashboardIds.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StreamDashboardPreviewsRequest {
+    return {
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      dashboardIds: globalThis.Array.isArray(object?.dashboardIds)
+        ? object.dashboardIds.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.dashboard_ids)
+        ? object.dashboard_ids.map((e: any) => globalThis.String(e))
+        : [],
+    };
+  },
+
+  toJSON(message: StreamDashboardPreviewsRequest): unknown {
+    const obj: any = {};
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.dashboardIds?.length) {
+      obj.dashboardIds = message.dashboardIds;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<StreamDashboardPreviewsRequest>, I>>(base?: I): StreamDashboardPreviewsRequest {
+    return StreamDashboardPreviewsRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<StreamDashboardPreviewsRequest>, I>>(
+    object: I,
+  ): StreamDashboardPreviewsRequest {
+    const message = createBaseStreamDashboardPreviewsRequest();
+    message.organizationId = object.organizationId ?? "";
+    message.projectId = object.projectId ?? "";
+    message.dashboardIds = object.dashboardIds?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseDashboardPreviewEnvelope(): DashboardPreviewEnvelope {
+  return { dashboardId: "", manifest: undefined, queryResult: undefined, error: undefined };
+}
+
+export const DashboardPreviewEnvelope: MessageFns<DashboardPreviewEnvelope> = {
+  encode(message: DashboardPreviewEnvelope, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.dashboardId !== "") {
+      writer.uint32(10).string(message.dashboardId);
+    }
+    if (message.manifest !== undefined) {
+      DashboardPreviewManifest.encode(message.manifest, writer.uint32(18).fork()).join();
+    }
+    if (message.queryResult !== undefined) {
+      DashboardPreviewQueryResult.encode(message.queryResult, writer.uint32(26).fork()).join();
+    }
+    if (message.error !== undefined) {
+      DashboardPreviewError.encode(message.error, writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DashboardPreviewEnvelope {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDashboardPreviewEnvelope();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.dashboardId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.manifest = DashboardPreviewManifest.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.queryResult = DashboardPreviewQueryResult.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.error = DashboardPreviewError.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DashboardPreviewEnvelope {
+    return {
+      dashboardId: isSet(object.dashboardId)
+        ? globalThis.String(object.dashboardId)
+        : isSet(object.dashboard_id)
+        ? globalThis.String(object.dashboard_id)
+        : "",
+      manifest: isSet(object.manifest) ? DashboardPreviewManifest.fromJSON(object.manifest) : undefined,
+      queryResult: isSet(object.queryResult)
+        ? DashboardPreviewQueryResult.fromJSON(object.queryResult)
+        : isSet(object.query_result)
+        ? DashboardPreviewQueryResult.fromJSON(object.query_result)
+        : undefined,
+      error: isSet(object.error) ? DashboardPreviewError.fromJSON(object.error) : undefined,
+    };
+  },
+
+  toJSON(message: DashboardPreviewEnvelope): unknown {
+    const obj: any = {};
+    if (message.dashboardId !== "") {
+      obj.dashboardId = message.dashboardId;
+    }
+    if (message.manifest !== undefined) {
+      obj.manifest = DashboardPreviewManifest.toJSON(message.manifest);
+    }
+    if (message.queryResult !== undefined) {
+      obj.queryResult = DashboardPreviewQueryResult.toJSON(message.queryResult);
+    }
+    if (message.error !== undefined) {
+      obj.error = DashboardPreviewError.toJSON(message.error);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DashboardPreviewEnvelope>, I>>(base?: I): DashboardPreviewEnvelope {
+    return DashboardPreviewEnvelope.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DashboardPreviewEnvelope>, I>>(object: I): DashboardPreviewEnvelope {
+    const message = createBaseDashboardPreviewEnvelope();
+    message.dashboardId = object.dashboardId ?? "";
+    message.manifest = (object.manifest !== undefined && object.manifest !== null)
+      ? DashboardPreviewManifest.fromPartial(object.manifest)
+      : undefined;
+    message.queryResult = (object.queryResult !== undefined && object.queryResult !== null)
+      ? DashboardPreviewQueryResult.fromPartial(object.queryResult)
+      : undefined;
+    message.error = (object.error !== undefined && object.error !== null)
+      ? DashboardPreviewError.fromPartial(object.error)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseDashboardPreviewManifest(): DashboardPreviewManifest {
+  return { widgets: [], dashboardVersion: 0 };
+}
+
+export const DashboardPreviewManifest: MessageFns<DashboardPreviewManifest> = {
+  encode(message: DashboardPreviewManifest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.widgets) {
+      Widget.encode(v!, writer.uint32(10).fork()).join();
+    }
+    if (message.dashboardVersion !== 0) {
+      writer.uint32(16).int64(message.dashboardVersion);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DashboardPreviewManifest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDashboardPreviewManifest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.widgets.push(Widget.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.dashboardVersion = longToNumber(reader.int64());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DashboardPreviewManifest {
+    return {
+      widgets: globalThis.Array.isArray(object?.widgets) ? object.widgets.map((e: any) => Widget.fromJSON(e)) : [],
+      dashboardVersion: isSet(object.dashboardVersion)
+        ? globalThis.Number(object.dashboardVersion)
+        : isSet(object.dashboard_version)
+        ? globalThis.Number(object.dashboard_version)
+        : 0,
+    };
+  },
+
+  toJSON(message: DashboardPreviewManifest): unknown {
+    const obj: any = {};
+    if (message.widgets?.length) {
+      obj.widgets = message.widgets.map((e) => Widget.toJSON(e));
+    }
+    if (message.dashboardVersion !== 0) {
+      obj.dashboardVersion = Math.round(message.dashboardVersion);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DashboardPreviewManifest>, I>>(base?: I): DashboardPreviewManifest {
+    return DashboardPreviewManifest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DashboardPreviewManifest>, I>>(object: I): DashboardPreviewManifest {
+    const message = createBaseDashboardPreviewManifest();
+    message.widgets = object.widgets?.map((e) => Widget.fromPartial(e)) || [];
+    message.dashboardVersion = object.dashboardVersion ?? 0;
+    return message;
+  },
+};
+
+function createBaseDashboardPreviewQueryResult(): DashboardPreviewQueryResult {
+  return { widgetId: "", queryIndex: 0, snapshot: undefined, error: undefined };
+}
+
+export const DashboardPreviewQueryResult: MessageFns<DashboardPreviewQueryResult> = {
+  encode(message: DashboardPreviewQueryResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.widgetId !== "") {
+      writer.uint32(10).string(message.widgetId);
+    }
+    if (message.queryIndex !== 0) {
+      writer.uint32(16).int32(message.queryIndex);
+    }
+    if (message.snapshot !== undefined) {
+      QuerySnapshot.encode(message.snapshot, writer.uint32(26).fork()).join();
+    }
+    if (message.error !== undefined) {
+      WidgetQueryError.encode(message.error, writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DashboardPreviewQueryResult {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDashboardPreviewQueryResult();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.widgetId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.queryIndex = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.snapshot = QuerySnapshot.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.error = WidgetQueryError.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DashboardPreviewQueryResult {
+    return {
+      widgetId: isSet(object.widgetId)
+        ? globalThis.String(object.widgetId)
+        : isSet(object.widget_id)
+        ? globalThis.String(object.widget_id)
+        : "",
+      queryIndex: isSet(object.queryIndex)
+        ? globalThis.Number(object.queryIndex)
+        : isSet(object.query_index)
+        ? globalThis.Number(object.query_index)
+        : 0,
+      snapshot: isSet(object.snapshot) ? QuerySnapshot.fromJSON(object.snapshot) : undefined,
+      error: isSet(object.error) ? WidgetQueryError.fromJSON(object.error) : undefined,
+    };
+  },
+
+  toJSON(message: DashboardPreviewQueryResult): unknown {
+    const obj: any = {};
+    if (message.widgetId !== "") {
+      obj.widgetId = message.widgetId;
+    }
+    if (message.queryIndex !== 0) {
+      obj.queryIndex = Math.round(message.queryIndex);
+    }
+    if (message.snapshot !== undefined) {
+      obj.snapshot = QuerySnapshot.toJSON(message.snapshot);
+    }
+    if (message.error !== undefined) {
+      obj.error = WidgetQueryError.toJSON(message.error);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DashboardPreviewQueryResult>, I>>(base?: I): DashboardPreviewQueryResult {
+    return DashboardPreviewQueryResult.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DashboardPreviewQueryResult>, I>>(object: I): DashboardPreviewQueryResult {
+    const message = createBaseDashboardPreviewQueryResult();
+    message.widgetId = object.widgetId ?? "";
+    message.queryIndex = object.queryIndex ?? 0;
+    message.snapshot = (object.snapshot !== undefined && object.snapshot !== null)
+      ? QuerySnapshot.fromPartial(object.snapshot)
+      : undefined;
+    message.error = (object.error !== undefined && object.error !== null)
+      ? WidgetQueryError.fromPartial(object.error)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseDashboardPreviewError(): DashboardPreviewError {
+  return { message: "" };
+}
+
+export const DashboardPreviewError: MessageFns<DashboardPreviewError> = {
+  encode(message: DashboardPreviewError, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DashboardPreviewError {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDashboardPreviewError();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DashboardPreviewError {
+    return { message: isSet(object.message) ? globalThis.String(object.message) : "" };
+  },
+
+  toJSON(message: DashboardPreviewError): unknown {
+    const obj: any = {};
+    if (message.message !== "") {
+      obj.message = message.message;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DashboardPreviewError>, I>>(base?: I): DashboardPreviewError {
+    return DashboardPreviewError.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DashboardPreviewError>, I>>(object: I): DashboardPreviewError {
+    const message = createBaseDashboardPreviewError();
+    message.message = object.message ?? "";
+    return message;
+  },
+};
+
 /**
  * MetricGatewayService is the web surface of telemetry.api.v1 MetricService — the types
  * are domain-isolated copies converted in gateways/internal/convert. It covers the
@@ -4302,6 +4830,19 @@ export interface MetricGatewayService {
    * conditions.
    */
   StreamDashboardData(request: StreamDashboardDataRequest, metadata?: Metadata): Observable<DashboardDataEnvelope>;
+  /**
+   * Batched preview for the dashboards LIST pane: one stream previews many
+   * boards. Per dashboard the backend picks a couple of representative widgets,
+   * emits their definitions (manifest) so the card renders without a per-board
+   * GetDashboard, then streams one cached snapshot per (widget, query) as each
+   * resolves. Fixed recent window, snapshot-once (never live); widget time pins
+   * are ignored — a card is an approximate teaser. See the telemetry-api service
+   * definition for the full ordering/cardinality guarantees.
+   */
+  StreamDashboardPreviews(
+    request: StreamDashboardPreviewsRequest,
+    metadata?: Metadata,
+  ): Observable<DashboardPreviewEnvelope>;
 }
 
 export const MetricGatewayServiceServiceName = "gateway.web.v1.MetricGatewayService";
@@ -4320,6 +4861,7 @@ export class MetricGatewayServiceClientImpl implements MetricGatewayService {
     this.UpdateDashboard = this.UpdateDashboard.bind(this);
     this.DeleteDashboard = this.DeleteDashboard.bind(this);
     this.StreamDashboardData = this.StreamDashboardData.bind(this);
+    this.StreamDashboardPreviews = this.StreamDashboardPreviews.bind(this);
   }
   StreamMetrics(request: StreamMetricsRequest, metadata?: Metadata): Observable<MetricCatalogEnvelope> {
     const data = StreamMetricsRequest.encode(request).finish();
@@ -4377,6 +4919,15 @@ export class MetricGatewayServiceClientImpl implements MetricGatewayService {
     const result = this.rpc.serverStreamingRequest(this.service, "StreamDashboardData", data, metadata);
     return result.pipe(map((data) => DashboardDataEnvelope.decode(new BinaryReader(data))));
   }
+
+  StreamDashboardPreviews(
+    request: StreamDashboardPreviewsRequest,
+    metadata?: Metadata,
+  ): Observable<DashboardPreviewEnvelope> {
+    const data = StreamDashboardPreviewsRequest.encode(request).finish();
+    const result = this.rpc.serverStreamingRequest(this.service, "StreamDashboardPreviews", data, metadata);
+    return result.pipe(map((data) => DashboardPreviewEnvelope.decode(new BinaryReader(data))));
+  }
 }
 
 interface Rpc {

package/proto/gateway/web/v1/metric_gateway_grpc_pb.js

@@ -40,6 +40,17 @@ function deserialize_gateway_web_v1_DashboardDataEnvelope(buffer_arg) {
   return proto_gateway_web_v1_metric_gateway_pb.DashboardDataEnvelope.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_gateway_web_v1_DashboardPreviewEnvelope(arg) {
+  if (!(arg instanceof proto_gateway_web_v1_metric_gateway_pb.DashboardPreviewEnvelope)) {
+    throw new Error('Expected argument of type gateway.web.v1.DashboardPreviewEnvelope');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gateway_web_v1_DashboardPreviewEnvelope(buffer_arg) {
+  return proto_gateway_web_v1_metric_gateway_pb.DashboardPreviewEnvelope.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_gateway_web_v1_DeleteDashboardRequest(arg) {
   if (!(arg instanceof proto_gateway_web_v1_metric_gateway_pb.DeleteDashboardRequest)) {
     throw new Error('Expected argument of type gateway.web.v1.DeleteDashboardRequest');
@@ -150,6 +161,17 @@ function deserialize_gateway_web_v1_StreamDashboardDataRequest(buffer_arg) {
   return proto_gateway_web_v1_metric_gateway_pb.StreamDashboardDataRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_gateway_web_v1_StreamDashboardPreviewsRequest(arg) {
+  if (!(arg instanceof proto_gateway_web_v1_metric_gateway_pb.StreamDashboardPreviewsRequest)) {
+    throw new Error('Expected argument of type gateway.web.v1.StreamDashboardPreviewsRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gateway_web_v1_StreamDashboardPreviewsRequest(buffer_arg) {
+  return proto_gateway_web_v1_metric_gateway_pb.StreamDashboardPreviewsRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_gateway_web_v1_StreamMetricAttributesRequest(arg) {
   if (!(arg instanceof proto_gateway_web_v1_metric_gateway_pb.StreamMetricAttributesRequest)) {
     throw new Error('Expected argument of type gateway.web.v1.StreamMetricAttributesRequest');
@@ -321,6 +343,24 @@ streamDashboardData: {
     responseSerialize: serialize_gateway_web_v1_DashboardDataEnvelope,
     responseDeserialize: deserialize_gateway_web_v1_DashboardDataEnvelope,
   },
+  // Batched preview for the dashboards LIST pane: one stream previews many
+// boards. Per dashboard the backend picks a couple of representative widgets,
+// emits their definitions (manifest) so the card renders without a per-board
+// GetDashboard, then streams one cached snapshot per (widget, query) as each
+// resolves. Fixed recent window, snapshot-once (never live); widget time pins
+// are ignored — a card is an approximate teaser. See the telemetry-api service
+// definition for the full ordering/cardinality guarantees.
+streamDashboardPreviews: {
+    path: '/gateway.web.v1.MetricGatewayService/StreamDashboardPreviews',
+    requestStream: false,
+    responseStream: true,
+    requestType: proto_gateway_web_v1_metric_gateway_pb.StreamDashboardPreviewsRequest,
+    responseType: proto_gateway_web_v1_metric_gateway_pb.DashboardPreviewEnvelope,
+    requestSerialize: serialize_gateway_web_v1_StreamDashboardPreviewsRequest,
+    requestDeserialize: deserialize_gateway_web_v1_StreamDashboardPreviewsRequest,
+    responseSerialize: serialize_gateway_web_v1_DashboardPreviewEnvelope,
+    responseDeserialize: deserialize_gateway_web_v1_DashboardPreviewEnvelope,
+  },
 };
 
 exports.MetricGatewayServiceClient = grpc.makeGenericClientConstructor(MetricGatewayServiceService, 'MetricGatewayService');