@gravitee/gamma-lib-observability 5.2.0 → 6.0.0

package/INTEGRATION.md

@@ -1332,6 +1332,17 @@ interface MetricsDataSource {
 }
 ```
 
+The request contract a custom source must honour:
+
+- `filters[]` can name the **same field several times** (a dashboard filter and a widget's own
+  filter on `HTTP_STATUS`, plus the host scope). Every condition must be ANDed: a source that keeps
+  only one per field lets a widget ignore the dashboard, or step outside the host's scope.
+- A metric-group `fetchMeasures` names each metric with an `id` (all or none), and can name the same
+  metric twice with different `metrics[].filters`. Echo each `id` on its `MetricResult`; results
+  without ids are read by metric name, and two tiles on one metric then show the same value.
+
+See [`QUERYING.md` §6](./QUERYING.md#6-filter-semantics).
+
 ### Custom filter providers
 
 Override the async-loaded filter definitions:

package/QUERYING.md

@@ -47,7 +47,8 @@ Which request fields each endpoint accepts (✅ supported, — not applicable):
 | `ranges`             | `NumericRange[]`            | `{ from: number; to: number }[]` — inclusive `from`, exclusive `to`.                                                            |
 | `metrics[].name`     | `string`                    | Metric name, e.g. `HTTP_REQUESTS`, `HTTP_GATEWAY_RESPONSE_TIME`, `LLM_PROMPT_TOTAL_TOKEN`.                                      |
 | `metrics[].measures` | `string[]`                  | `AVG`, `MIN`, `MAX`, `P50`, `P90`, `P95`, `P99`, `COUNT`, `PERCENTAGE`.                                                         |
-| `metrics[].filters`  | `FilterCondition[]`         | Per-metric filters (same shape as top-level filters).                                                                           |
+| `metrics[].id`       | `string`                    | **measures only.** The caller's name for the metric, echoed on its result. All metrics of a request or none (§5.5).             |
+| `metrics[].filters`  | `FilterCondition[]`         | Per-metric filters (same shape as top-level filters), ANDed with them. **measures only.**                                       |
 | `metrics[].sorts`    | `MeasureSort[]`             | `{ measure, order: 'ASC' \| 'DESC' }[]` (facets & grouped time-series only).                                                    |
 | filter `operator`    | `eq` / `in` / `gte` / `lte` | Mapped to wire `EQ` / `IN` / `GTE` / `LTE`. Other lib operators throw at serialization time.                                    |
 
@@ -203,7 +204,15 @@ Each example shows the widget config and the resulting request payload.
 }
 ```
 
-→ `{ metrics: [ { name: 'HTTP_REQUESTS', measures: ['COUNT'] }, { name: 'HTTP_ERRORS', measures: ['COUNT'], filters: [{ name: 'HTTP_STATUS_CODE_GROUP', operator: 'EQ', value: '5xx' }] } ], timeRange }`
+→ `{ metrics: [ { id: 'HTTP_REQUESTS::', name: 'HTTP_REQUESTS', measures: ['COUNT'] }, { id: 'HTTP_ERRORS::[…]', name: 'HTTP_ERRORS', measures: ['COUNT'], filters: [{ name: 'HTTP_STATUS_CODE_GROUP', operator: 'EQ', value: '5xx' }] } ], timeRange }`
+
+Every metric of a metric-group request carries an `id`: its metric and its own conditions. Tiles
+sharing both share an entry, and two tiles on **the same metric** with different filters (`Requests`
+and `5xx requests` on `HTTP_REQUESTS`) each get their own value. The response echoes each `id`, and
+tiles are read by it, the previous-period request included. A source whose results carry no `id` is
+read by metric name, and two tiles on one metric then show the same value. A metric group can use at
+most 10 distinct sets of tile filters (tiles without filters do not count): the JSON tab refuses more.
+A Management API older than OBS-132 ignores the ids and does not apply tile filters.
 
 ### 5.6 Dual-axis combo chart (mixed bar + line)
 
@@ -288,37 +297,54 @@ order is the priority.
 
 ## 6. Filter semantics
 
-Filters merge in this order, later layers win on a field conflict:
+A widget's request carries two layers, **appended, never merged into each other**:
 
 ```
-dashboard definition (re-valuable default) → reader URL filters → dashboard definition (locked) → widget (widget.filters) → series/item (series[].filters / items[].filters)
+dashboard layer:  definition (re-valuable default) → reader URL filters → definition (locked)
+then:             widget (widget.filters) → series (series[].filters)
 ```
 
-**The host's context scope sits above all of it as a ceiling, not as a layer.** A module mounted with
-`scopeApiTypes` (or explicit `contextFilters`) always carries that scope, and any condition on a
-scoped field is intersected with it: a later layer can narrow inside the scope, never step outside
-it. An intersection that comes out empty falls back to the host's own values rather than to no
-condition at all, because a value-less condition is dropped before the request and would leave the
-query unscoped. Only ceilings whose operator is `eq` or `in` are enforced this way. See
-`clampToScope` in `src/filters/scope-ceiling.ts`.
+Inside the **dashboard layer**, a later source replaces an earlier one on the same field: a reader
+value replaces the default, a locked definition filter holds. A dashboard keeps one filter per field.
+See `resolveDashboardFilters` for how a reader's URL filters are reconciled with it.
+
+The widget's and the series' own filters are then **appended** to that list, never replacing it.
+The same field can appear several times in `filters[]`, and the analytics API ANDs every top-level
+condition (OBS-132). A widget filter therefore **combines** with the dashboard's, like Kibana,
+Datadog, Grafana and New Relic do: a "5xx" widget under a dashboard filtered on `HTTP_STATUS = 200`
+answers 0 rather than ignoring the dashboard. The editor flags a widget, series or tile value that can
+never overlap a **locked** dashboard value ("These widgets will be empty under the dashboard filters").
+
+Metric-group tile filters (`items[].filters`) stay on their metric (`metrics[].filters`, measures
+only), where the API ANDs them with the request's `filters[]`; see §5.5. Facets and time-series never
+carry per-metric filters.
+
+> **Requires a Management API with OBS-132.** An older one refuses a repeated top-level field
+> (`observability.filter.repeated`, HTTP 400) and does not apply tile filters.
+
+**The host's context scope sits above all of it as a ceiling.** A module mounted with
+`scopeApiTypes` (or explicit `contextFilters`) always sends that scope, and every other condition is
+sent beside it: the API ANDs them, so a request can never leave the scope. A widget pinned entirely
+outside it answers 0, and a `contains`, `gte` or `lte` on a scoped field narrows inside it. A
+condition identical to one already listed (same field, operator and values, in any order) is sent
+once. See `clampAnalyticsToScope` in `src/filters/scope-ceiling.ts`.
+
+**Logs keep the older clamp** (`clampToScope`): the logs search refuses a repeated field, so a
+condition on a scoped field is intersected with the scope, and an empty intersection falls back to
+the host's own values.
 
 The clamp happens at the data source, not at each call site. `useMetricsDataSource`,
 `useLogsDataSource` and their `useOptional*` variants return a source that clamps the top-level
 `filters` of every request against the context filters before delegating to the one the host
-mounted, so a component that queries the source directly, or merges a filter after its own clamp,
+mounted, so a component that queries the source directly, or appends a filter after its own clamp,
 still cannot step outside the scope. The query hooks clamp as well, because their cache keys are
 derived from the filters actually sent; clamping twice changes nothing. Per-metric `filters` are
-not clamped (the server ANDs them under the top-level ones), and neither is the `apiId` passed to
+not clamped (the API ANDs them with the top-level ones), and neither is the `apiId` passed to
 `getById`. See `src/providers/clamped-data-sources.ts`.
 
-Within a dashboard, a definition filter is locked or re-valuable (`editable`); see
-`resolveDashboardFilters` for how a reader's URL filters are reconciled with it.
+A custom `MetricsDataSource` must AND repeated fields in `filters[]`, and should echo each metric's
+`id` on its result.
 
-- The merged top-level filters are sent as the request `filters[]`. Item filters (`items[].filters`)
-  are sent as per-metric `filters[]`; series filters are merged into the top-level `filters[]` of
-  that series' own request, since each series is one request. The Gamma analytics endpoints validate
-  per-metric filters but do not apply them yet: they come back in that metric's `ignoredFilters`, so
-  the widget says so instead of showing an unfiltered number as filtered.
 - Operators are mapped to the v2 wire format: `eq → EQ`, `in → IN`, `gte → GTE`, `lte → LTE`.
   `eq`/`gte`/`lte` take a single value; `in` takes an array. Unsupported operators throw with a clear
   error rather than silently dropping the filter.

package/USAGE_GUIDE.md

@@ -187,6 +187,17 @@ export const myMetricsDataSource: MetricsDataSource = {
 
 Pass it as the `dataSource` prop on `<observability.Routes>` to override the built-in adapter.
 
+The request contract a custom source must honour:
+
+- `filters[]` can name the **same field several times** (a dashboard filter and a widget's own
+  filter on `HTTP_STATUS`, plus the host scope). Every condition must be ANDed: a source that keeps
+  only one per field lets a widget ignore the dashboard, or step outside the host's scope.
+- A metric-group `fetchMeasures` names each metric with an `id` (all or none), and can name the same
+  metric twice with different `metrics[].filters`. Echo each `id` on its `MetricResult`; results
+  without ids are read by metric name, and two tiles on one metric then show the same value.
+
+See [`QUERYING.md` §6](./QUERYING.md#6-filter-semantics).
+
 ### Custom LogsDataSource
 
 ```ts
@@ -244,7 +255,7 @@ When no `CapabilityProvider` is present, all capabilities default to `false` (se
 - `TimeSeriesPoint` — `{ timestamp, value }`
 - `TimeSeriesGroup` — `{ key, label, points, ignoredFilters? }`
 - `FacetBucket` — `{ value, label, count, metric?, unit?, measures?, ignoredFilters? }`
-- `MetricResult` — `{ name, unit?, measures, ignoredFilters? }`. `ignoredFilters` names the filters the backend could not apply to the metric; see [`QUERYING.md`](./QUERYING.md#filters-a-metric-could-not-apply)
+- `MetricResult` — `{ id?, name, unit?, measures, ignoredFilters? }`. `id` echoes the request metric's `id` when the request named its metrics by id (metric groups). `ignoredFilters` names the filters the backend could not apply to the metric; see [`QUERYING.md`](./QUERYING.md#filters-a-metric-could-not-apply)
 - `MeasureValue` — `{ key, label, value, unit?, previousValue? }`
 - `TraceSummary` — trace list entry (traceId, rootOperationName, rootServiceName, startTime, duration, spanCount, status)
 - `TraceDetail` — full trace with span tree (extends summary with `spans: Span[]`)
@@ -362,6 +373,8 @@ import { DashboardWidget } from '@gravitee/graphene-charts/dashboard-grid';
 
 `WidgetGroup` filters are passed to renderers via the `filters` prop. If a page-level `ContextFiltersProvider` is also present, renderers will merge both sources — group filters **compose with** page filters, they do not replace them.
 
+A widget's own `filters` (and a series' or a metric-group tile's) compose the same way: they are sent **beside** the group filters, never in their place, and the analytics API ANDs them, the same field included. A widget filtered on `HTTP_STATUS = 500` inside a group filtered on `HTTP_STATUS = 200` shows nothing. A custom renderer registered with `registerWidgetRenderer` gets this from `useMergedWidgetFilters(widget.filters, filters)`, and appends anything of its own below the widget to the list it returns. See [`QUERYING.md` §6](./QUERYING.md#6-filter-semantics).
+
 ### Level 3 — `WidgetItem` standalone (isolated widget)
 
 Use when embedding a single widget in a sidebar, card, or other context.

package/dist/dashboard-access-provider.js

@@ -36,8 +36,8 @@ function d(e) {
 }
 //#endregion
 //#region src/dashboards/grid.ts
-var f = 24, p = 2, m = 12, h = 24 / m;
-function ee(e) {
+var ee = 24, f = 2, p = 12, m = 24 / p;
+function te(e) {
 	if (typeof e != "object" || !e) return "unreadable";
 	let t = typeof e.version == "number" ? e.version : void 0;
 	if (t !== void 0 && t >= 2) return "current";
@@ -47,18 +47,18 @@ function ee(e) {
 		r,
 		i,
 		a
-	].every((e) => Number.isFinite(e)) ? t === void 0 && n + i > m ? "current-unmarked" : "legacy" : "unreadable";
+	].every((e) => Number.isFinite(e)) ? t === void 0 && n + i > p ? "current-unmarked" : "legacy" : "unreadable";
 }
-function te(e) {
-	switch (ee(e)) {
+function h(e) {
+	switch (te(e)) {
 		case "legacy": return {
-			x: e.x * h,
-			y: e.y * h,
-			cols: e.cols * h,
-			rows: e.rows * h,
+			x: e.x * m,
+			y: e.y * m,
+			cols: e.cols * m,
+			rows: e.rows * m,
 			version: 2,
-			...e.minCols !== void 0 && { minCols: e.minCols * h },
-			...e.minRows !== void 0 && { minRows: e.minRows * h }
+			...e.minCols !== void 0 && { minCols: e.minCols * m },
+			...e.minRows !== void 0 && { minRows: e.minRows * m }
 		};
 		case "current-unmarked": return {
 			...e,
@@ -71,7 +71,7 @@ function te(e) {
 function g(e) {
 	if (!e || !Array.isArray(e.widgets)) return e;
 	let t = !1, n = e.widgets.map((e) => {
-		let n = te(e.layout);
+		let n = h(e.layout);
 		return n === e.layout ? e : (t = !0, {
 			...e,
 			layout: n
@@ -214,11 +214,25 @@ function L(e, t) {
 	return n.flatMap((e) => {
 		let t = r.get(e.field);
 		if (!t || e === t) return [e];
-		let n = R(e, t);
+		let n = B(e, t);
 		return n === t ? i.has(e.field) ? [] : (i.add(e.field), [t]) : [n];
 	});
 }
 function R(e, t) {
+	let n = /* @__PURE__ */ new Set();
+	return [...e, ...t ?? []].filter((e) => {
+		let t = z(e);
+		return n.has(t) ? !1 : (n.add(t), !0);
+	});
+}
+function z(e) {
+	return JSON.stringify([
+		e.field,
+		e.operator,
+		[...e.value].sort()
+	]);
+}
+function B(e, t) {
 	if (!I.has(e.operator)) return t;
 	let n = new Set(t.value), r = e.value.map((e, t) => n.has(e) ? t : -1).filter((e) => e >= 0);
 	return r.length === 0 ? t : r.length === e.value.length ? e : {
@@ -229,23 +243,23 @@ function R(e, t) {
 }
 //#endregion
 //#region src/providers/clamped-data-sources.ts
-function z(e, t) {
+function V(e, t) {
 	return {
 		fetchTimeSeries: (n) => e.fetchTimeSeries({
 			...n,
-			filters: L(t, n.filters)
+			filters: R(t, n.filters)
 		}),
 		fetchFacets: (n) => e.fetchFacets({
 			...n,
-			filters: L(t, n.filters)
+			filters: R(t, n.filters)
 		}),
 		fetchMeasures: (n) => e.fetchMeasures({
 			...n,
-			filters: L(t, n.filters)
+			filters: R(t, n.filters)
 		})
 	};
 }
-function B(e, t) {
+function H(e, t) {
 	let n = e.getById;
 	return {
 		fetchLogs: (n) => e.fetchLogs({
@@ -257,78 +271,78 @@ function B(e, t) {
 }
 //#endregion
 //#region src/providers/logs-data-source-provider.tsx
-var V = e(null);
-function H({ dataSource: e, children: t }) {
-	return /* @__PURE__ */ a(V.Provider, {
+var U = e(null);
+function W({ dataSource: e, children: t }) {
+	return /* @__PURE__ */ a(U.Provider, {
 		value: e,
 		children: t
 	});
 }
-function U() {
-	let e = W();
+function ae() {
+	let e = G();
 	if (!e) throw Error("[gamma-lib-observability] useLogsDataSource must be used within a <LogsDataSourceProvider>. Wrap your component tree with <LogsDataSourceProvider dataSource={yourImpl}>.");
 	return e;
 }
-function W() {
-	let e = n(V), t = A();
-	return r(() => e ? B(e, t) : null, [e, t]);
+function G() {
+	let e = n(U), t = A();
+	return r(() => e ? H(e, t) : null, [e, t]);
 }
 //#endregion
 //#region src/providers/metrics-data-source-provider.tsx
-var G = e(null);
-function K({ dataSource: e, children: t }) {
-	return /* @__PURE__ */ a(G.Provider, {
+var K = e(null);
+function q({ dataSource: e, children: t }) {
+	return /* @__PURE__ */ a(K.Provider, {
 		value: e,
 		children: t
 	});
 }
-function q() {
-	let e = J();
+function J() {
+	let e = Y();
 	if (!e) throw Error("[gamma-lib-observability] useMetricsDataSource must be used within a <MetricsDataSourceProvider>. Wrap your component tree with <MetricsDataSourceProvider dataSource={yourImpl}>.");
 	return e;
 }
-function J() {
-	let e = n(G), t = A();
-	return r(() => e ? z(e, t) : null, [e, t]);
+function Y() {
+	let e = n(K), t = A();
+	return r(() => e ? V(e, t) : null, [e, t]);
 }
 //#endregion
 //#region src/providers/traces-data-source-provider.tsx
-var Y = e(null);
-function ae({ dataSource: e, children: t }) {
-	return /* @__PURE__ */ a(Y.Provider, {
+var X = e(null);
+function oe({ dataSource: e, children: t }) {
+	return /* @__PURE__ */ a(X.Provider, {
 		value: e,
 		children: t
 	});
 }
-function oe() {
-	let e = n(Y);
+function se() {
+	let e = n(X);
 	if (!e) throw Error("[gamma-lib-observability] useTracesDataSource must be used within a <TracesDataSourceProvider>. Wrap your component tree with <TracesDataSourceProvider dataSource={yourImpl}>.");
 	return e;
 }
-function se() {
-	return n(Y);
+function ce() {
+	return n(X);
 }
 //#endregion
 //#region src/filters/filter-providers-context.tsx
-var X = e(null);
-function ce({ providers: e, children: t }) {
+var Z = e(null);
+function le({ providers: e, children: t }) {
 	let n = r(() => e, [e]);
-	return /* @__PURE__ */ a(X.Provider, {
+	return /* @__PURE__ */ a(Z.Provider, {
 		value: n,
 		children: t
 	});
 }
-function Z() {
-	let e = n(X);
+function Q() {
+	let e = n(Z);
 	if (!e) throw Error("[gamma-lib-observability] useFilterProviders must be used within a <FilterProvidersProvider>. Wrap your component tree with <FilterProvidersProvider providers={[...]}>.");
 	return e;
 }
-function le() {
-	return n(X) ?? ue;
+function ue() {
+	return n(Z) ?? de;
 }
-var ue = Object.freeze([]);
-function Q(e) {
-	let t = Z();
+var de = Object.freeze([]);
+function fe(e) {
+	let t = Q();
 	if (e) return t.find((t) => t.field === e);
 }
 //#endregion
@@ -339,7 +353,7 @@ var $ = e({
 	reportRefused: () => {},
 	reportGranted: () => {}
 });
-function de({ children: e }) {
+function pe({ children: e }) {
 	let [n, o] = i({
 		read: !1,
 		write: !1
@@ -369,8 +383,8 @@ function de({ children: e }) {
 		children: e
 	});
 }
-function fe() {
+function me() {
 	return n($);
 }
 //#endregion
-export { f as A, re as C, _ as D, y as E, d as F, s as I, o as L, g as M, l as N, S as O, u as P, ie as S, v as T, M as _, Z as a, A as b, se as c, q as d, J as f, L as g, W as h, Q as i, p as j, x as k, oe as l, U as m, fe as n, le as o, H as p, ce as r, ae as s, de as t, K as u, N as v, b as w, ne as x, k as y };
+export { x as A, ie as C, y as D, v as E, u as F, d as I, s as L, f as M, g as N, _ as O, l as P, o as R, ne as S, b as T, L as _, Q as a, k as b, ce as c, J as d, Y as f, R as g, G as h, fe as i, ee as j, S as k, se as l, ae as m, me as n, ue as o, W as p, le as r, oe as s, pe as t, q as u, M as v, re as w, A as x, N as y };

package/dist/dashboards/editor/DashboardEditorPage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DashboardEditorPage.d.ts","sourceRoot":"","sources":["../../../src/dashboards/editor/DashboardEditorPage.tsx"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,wBAAgB,mBAAmB,CAAC,EAAE,gBAAgB,EAAE,EAAE,wBAAwB,2CAYjF"}
+{"version":3,"file":"DashboardEditorPage.d.ts","sourceRoot":"","sources":["../../../src/dashboards/editor/DashboardEditorPage.tsx"],"names":[],"mappings":"AAiFA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,wBAAgB,mBAAmB,CAAC,EAAE,gBAAgB,EAAE,EAAE,wBAAwB,2CAYjF"}

package/dist/dashboards/editor/WidgetConfigForm.d.ts

@@ -1,7 +1,12 @@
-import { Widget } from '../../types/domain';
+import { FilterCondition, Widget } from '../../types/domain';
 export interface WidgetConfigFormProps {
     readonly widget: Widget;
     readonly onChange: (widget: Widget) => void;
+    /**
+     * The dashboard's own filters. Its locked ones, like the host's scope, decide
+     * whether a scoped metric still needs its `API_TYPE` stamped on the widget.
+     */
+    readonly dashboardFilters?: readonly FilterCondition[];
 }
 /**
  * Controlled configuration form for a single widget. Every change is emitted
@@ -13,5 +18,5 @@ export interface WidgetConfigFormProps {
  * The visualization picker stays above the tabs: it decides which tabs exist,
  * so it cannot live inside one of them.
  */
-export declare function WidgetConfigForm({ widget, onChange }: WidgetConfigFormProps): import("react/jsx-runtime").JSX.Element;
+export declare function WidgetConfigForm({ widget, onChange, dashboardFilters }: WidgetConfigFormProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=WidgetConfigForm.d.ts.map

package/dist/dashboards/editor/WidgetConfigForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WidgetConfigForm.d.ts","sourceRoot":"","sources":["../../../src/dashboards/editor/WidgetConfigForm.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAKV,MAAM,EAEP,MAAM,oBAAoB,CAAC;AAkB5B,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7C;AAYD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,qBAAqB,2CAsE3E"}
+{"version":3,"file":"WidgetConfigForm.d.ts","sourceRoot":"","sources":["../../../src/dashboards/editor/WidgetConfigForm.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAEV,eAAe,EAGf,MAAM,EAEP,MAAM,oBAAoB,CAAC;AAkB5B,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;CACxD;AAYD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,EAAE,qBAAqB,2CA4E7F"}

package/dist/dashboards/editor/WidgetPreview.d.ts

@@ -8,7 +8,7 @@ export interface WidgetPreviewProps {
 /**
  * Live preview of the widget under edition. The configuration is debounced so
  * typing does not fire an analytics query per keystroke; widget-level filters
- * are merged by the renderer itself (widget wins over dashboard filters).
+ * are added by the renderer itself, beside the dashboard's.
  *
  * The preview takes the panel's full width, the way Grafana's and Datadog's
  * editors do, rather than reproducing the widget's grid width: the author is

package/dist/dashboards/editor/dashboard-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dashboard-json.d.ts","sourceRoot":"","sources":["../../../src/dashboards/editor/dashboard-json.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,SAAS,EAKf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAGL,KAAK,qBAAqB,EAE1B,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAoB,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAY1F,MAAM,MAAM,wBAAwB,GAChC;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAA;CAAE,GAC/D;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAE/D,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAC;CAC1C;AAKD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAO/D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,EAAE,OAAY,EAAE,GAAE,yBAA8B,GAC/C,wBAAwB,CAqC1B;AAiGD,6GAA6G;AAC7G,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAI3E"}
+{"version":3,"file":"dashboard-json.d.ts","sourceRoot":"","sources":["../../../src/dashboards/editor/dashboard-json.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,SAAS,EAKf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAGL,KAAK,qBAAqB,EAE1B,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAoB,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAY1F,MAAM,MAAM,wBAAwB,GAChC;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAA;CAAE,GAC/D;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAE/D,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAC;CAC1C;AAKD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAO/D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,EAAE,OAAY,EAAE,GAAE,yBAA8B,GAC/C,wBAAwB,CAqC1B;AAmGD,6GAA6G;AAC7G,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAI3E"}

package/dist/dashboards/editor/locked-filter-conflicts.d.ts

@@ -9,26 +9,43 @@ export interface LockedFilterConflict {
     readonly widgetId: string;
     /** Falls back to the id: a widget can be saved before it is named. */
     readonly widgetTitle: string;
+    /**
+     * The chart series or metric tile whose own filter empties it, by its label.
+     * Absent when the widget's own filters already do.
+     */
+    readonly part?: string;
     readonly field: string;
     readonly label: string;
     readonly dashboard: ConflictingCondition;
-    /** Every condition the widget sets on the field: two for a range. */
+    /** Every condition the widget (and the part) sets on the field: two for a range. */
     readonly widget: readonly ConflictingCondition[];
 }
 /**
- * Widgets whose own filters override a locked dashboard filter.
+ * Widgets that will show nothing under a locked dashboard filter.
  *
- * Widget filters are merged last, so on a shared field the widget's value is
- * the one queried, whatever the padlock on the dashboard chip says. Within the
- * host's module scope, which still clamps it either way. That is
- * deliberate (see `ObservabilityDashboardPage`), which is exactly why the
- * author has to be told: nothing downstream will. Most of these are written
- * without anyone typing them, by `withAutoScope` stamping the `API_TYPE` a
- * metric requires, so the contradiction can appear from picking a metric.
+ * A widget's, series' or tile's own filters are sent alongside the dashboard's
+ * and the analytics API ANDs them, the same field included. So a widget value
+ * that can never overlap a locked dashboard value empties the widget, and the
+ * author has to be told: the reader only sees a 0. Most widget filters are
+ * written by `withAutoScope` rather than typed, so the contradiction can appear
+ * just from picking a metric.
  *
- * A widget carrying the *same* value is not a conflict. It is what the AIM
- * templates do today, pinning every widget to the API type the dashboard is
- * about, and flagging it would cry wolf on the common case.
+ * Only locked filters are checked: a reader can change a default, and the
+ * widget then fills again. Only what can be decided is flagged (see
+ * `canOverlap`), so a warning is never a false alarm.
  */
 export declare function findLockedFilterConflicts(dashboardFilters: readonly FilterCondition[], widgets: readonly Widget[]): LockedFilterConflict[];
+/**
+ * Whether conditions on one field, ANDed, can still match a value. Only what
+ * can be decided answers `false`:
+ *
+ * - value sets (`eq`, `in`) with no common value;
+ * - a value set whose every value is excluded (`neq`, `not_in`);
+ * - bounds that cross (`gte` above `lte`), or that leave out every listed
+ *   numeric value.
+ *
+ * Anything else may match: `contains`, a value without a value set, or a
+ * non-numeric value against a bound.
+ */
+export declare function canOverlap(conditions: readonly FilterCondition[]): boolean;
 //# sourceMappingURL=locked-filter-conflicts.d.ts.map

package/dist/dashboards/editor/locked-filter-conflicts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"locked-filter-conflicts.d.ts","sourceRoot":"","sources":["../../../src/dashboards/editor/locked-filter-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAGlF,yEAAyE;AACzE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAC;CAClD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,gBAAgB,EAAE,SAAS,eAAe,EAAE,EAC5C,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,oBAAoB,EAAE,CA2BxB"}
+{"version":3,"file":"locked-filter-conflicts.d.ts","sourceRoot":"","sources":["../../../src/dashboards/editor/locked-filter-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIlF,yEAAyE;AACzE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,oFAAoF;IACpF,QAAQ,CAAC,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAC;CAClD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,gBAAgB,EAAE,SAAS,eAAe,EAAE,EAC5C,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,oBAAoB,EAAE,CA4BxB;AAmBD;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CA+B1E"}

package/dist/dashboards/editor/widget-auto-scope.d.ts

@@ -1,14 +1,19 @@
-import { Widget } from '../../types/domain';
+import { FilterCondition, Widget } from '../../types/domain';
 /**
  * Ensures widgets whose metrics belong to a specific API type always carry the
  * owning `API_TYPE` filter, because querying a scoped metric without it fails
  * server-side (GMA-414). The filter is applied as a regular, visible widget
  * filter so the user can still broaden it deliberately.
  *
+ * Not when `upstream` (the dashboard's locked filters and the host's scope)
+ * already constrains `API_TYPE`: the query then carries one anyway, and a
+ * widget filter is ANDed with it, so a stamped type the dashboard does not
+ * allow would only empty the widget.
+ *
  * It is applied only when the edit actually changes which metrics or
  * dimensions are referenced. Re-deriving it on every edit would make the chip
  * impossible to remove: dropping it and then toggling any unrelated control
  * would silently bring it back.
  */
-export declare function withAutoScope(previous: Widget, next: Widget): Widget;
+export declare function withAutoScope(previous: Widget, next: Widget, upstream?: readonly FilterCondition[]): Widget;
 //# sourceMappingURL=widget-auto-scope.d.ts.map

package/dist/dashboards/editor/widget-auto-scope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"widget-auto-scope.d.ts","sourceRoot":"","sources":["../../../src/dashboards/editor/widget-auto-scope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AA2BjD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKpE"}
+{"version":3,"file":"widget-auto-scope.d.ts","sourceRoot":"","sources":["../../../src/dashboards/editor/widget-auto-scope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAqClE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,eAAe,EAAO,GAAG,MAAM,CAK/G"}

package/dist/dashboards/merge-filters.d.ts

@@ -7,16 +7,19 @@ export declare function isRangeBound(filter: FilterCondition): boolean;
  * each field.
  *
  * This is the mechanism, not the policy: it does not know which source is which
- * and has no canonical order of its own. The host's scope is applied on top by
- * `clampToScope`, which is what actually decides precedence and is the only
- * place that describes the full chain.
+ * and has no canonical order of its own. It resolves the **dashboard layer**
+ * (definition default, reader value, locked definition filter) into one
+ * condition per field. A widget's and a series' own filters are not merged
+ * with it: they are appended after it and the analytics API ANDs them (see
+ * `useMergedWidgetFilters`). The host's scope sits above both
+ * (`clampAnalyticsToScope`, `clampToScope` for logs).
  *
  * Within one source, a field keeps its last condition, with one exception: a
  * field whose conditions are all `gte` / `lte` keeps one of each, so
  * `latency gte 100` and `latency lte 500` stay a range the server ANDs. A
  * repeated bound still replaces the earlier one. Between sources, a later one
- * replaces the whole field, range included, so a widget's range overrides the
- * dashboard's rather than mixing a bound from each.
+ * replaces the whole field, range included, so a reader's range replaces the
+ * dashboard default rather than mixing a bound from each.
  */
 export declare function mergeFilters(...sources: (readonly FilterCondition[] | undefined)[]): FilterCondition[];
 //# sourceMappingURL=merge-filters.d.ts.map

package/dist/dashboards/merge-filters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merge-filters.d.ts","sourceRoot":"","sources":["../../src/dashboards/merge-filters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAkB,MAAM,iBAAiB,CAAC;AAKvE,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAE7D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,GAAG,OAAO,EAAE,CAAC,SAAS,eAAe,EAAE,GAAG,SAAS,CAAC,EAAE,GAAG,eAAe,EAAE,CAWtG"}
+{"version":3,"file":"merge-filters.d.ts","sourceRoot":"","sources":["../../src/dashboards/merge-filters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAkB,MAAM,iBAAiB,CAAC;AAKvE,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAE7D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,GAAG,OAAO,EAAE,CAAC,SAAS,eAAe,EAAE,GAAG,SAAS,CAAC,EAAE,GAAG,eAAe,EAAE,CAWtG"}

package/dist/dashboards/metric-group-requests.d.ts

@@ -0,0 +1,35 @@
+import { FilterCondition, MetricGroupItemDefinition } from '../types/domain';
+import { MetricRequest } from '../types/requests';
+import { MetricResult } from '../types/responses';
+/**
+ * Most distinct sets of tile filters one metric group may carry: the analytics
+ * API runs one query per set and refuses a request with more (OBS-132). Tiles
+ * without filters of their own do not count.
+ */
+export declare const MAX_ITEM_FILTER_SETS = 10;
+type ItemQuery = Pick<MetricGroupItemDefinition, 'metric' | 'filters'>;
+/**
+ * The id of the request entry a tile reads: its metric and its own conditions.
+ * Tiles sharing both share an entry, and the id is the same in the current and
+ * the previous-period requests.
+ */
+export declare function metricGroupItemId(item: ItemQuery): string;
+/**
+ * The measures request of a metric group: one entry per distinct metric and
+ * tile conditions, every entry named by its id. The tile's conditions stay on
+ * the entry (`metrics[].filters`), where the API ANDs them with the request's
+ * own, so two tiles on one metric with different filters each get their value.
+ */
+export declare function buildMetricGroupRequests(items: readonly MetricGroupItemDefinition[]): MetricRequest[];
+/**
+ * Finds the entry a tile reads: by id when the source echoed the ids, by metric
+ * name when no entry carries one (a custom data source, or a backend older than
+ * OBS-132). Read by name, two tiles on one metric show the same value.
+ */
+export declare function readMetricGroupResult(results: readonly MetricResult[] | undefined): (item: ItemQuery) => MetricResult | undefined;
+/** How many distinct, non-empty sets of filters the tiles carry, the number `MAX_ITEM_FILTER_SETS` caps. */
+export declare function countItemFilterSets(items: readonly {
+    readonly filters?: readonly FilterCondition[];
+}[]): number;
+export {};
+//# sourceMappingURL=metric-group-requests.d.ts.map

package/dist/dashboards/metric-group-requests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metric-group-requests.d.ts","sourceRoot":"","sources":["../../src/dashboards/metric-group-requests.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC,KAAK,SAAS,GAAG,IAAI,CAAC,yBAAyB,EAAE,QAAQ,GAAG,SAAS,CAAC,CAAC;AAYvE;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAEzD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,SAAS,yBAAyB,EAAE,GAAG,aAAa,EAAE,CAerG;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,GAC3C,CAAC,IAAI,EAAE,SAAS,KAAK,YAAY,GAAG,SAAS,CAQ/C;AAED,4GAA4G;AAC5G,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,EAAE,GAAG,MAAM,CAE/G"}

package/dist/dashboards/renderers/CartesianWidgetRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CartesianWidgetRenderer.d.ts","sourceRoot":"","sources":["../../../src/dashboards/renderers/CartesianWidgetRenderer.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAoB,MAAM,oBAAoB,CAAC;AAQ5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAGvE,wBAAgB,uBAAuB,CAAC,EACtC,MAAM,EACN,SAAS,EACT,OAAO,EACP,eAAe,GAChB,EAAE,mBAAmB,CAAC,eAAe,CAAC,2CA0HtC"}
+{"version":3,"file":"CartesianWidgetRenderer.d.ts","sourceRoot":"","sources":["../../../src/dashboards/renderers/CartesianWidgetRenderer.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAoB,MAAM,oBAAoB,CAAC;AAO5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAGvE,wBAAgB,uBAAuB,CAAC,EACtC,MAAM,EACN,SAAS,EACT,OAAO,EACP,eAAe,GAChB,EAAE,mBAAmB,CAAC,eAAe,CAAC,2CAyHtC"}

package/dist/dashboards/renderers/MetricGroupWidgetRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MetricGroupWidgetRenderer.d.ts","sourceRoot":"","sources":["../../../src/dashboards/renderers/MetricGroupWidgetRenderer.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAA8C,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAQxG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AA6CvE,wBAAgB,yBAAyB,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,mBAAmB,CAAC,iBAAiB,CAAC,2CA8G/G"}
+{"version":3,"file":"MetricGroupWidgetRenderer.d.ts","sourceRoot":"","sources":["../../../src/dashboards/renderers/MetricGroupWidgetRenderer.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAA6B,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AASvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAGvE,wBAAgB,yBAAyB,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,mBAAmB,CAAC,iBAAiB,CAAC,2CA2G/G"}