@meshmakers/octo-meshboard 3.5.490 → 3.5.510

package/types/meshmakers-octo-meshboard.d.ts

@@ -1,14 +1,14 @@
 import { ProcessWidgetSpecificConfig } from '@meshmakers/octo-process-diagrams';
 import * as _angular_core from '@angular/core';
 import { Signal, AfterViewInit, OnChanges, EventEmitter, SimpleChanges, Type, OnDestroy, OnInit, EnvironmentProviders, InjectionToken, Provider } from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
-import * as i1 from '@meshmakers/shared-ui';
-import { EntitySelectDialogDataSource, ColumnDefinition, DialogFetchOptions, DialogFetchResult, EntitySelectInputComponent, TimeRange, FetchDataOptions, FetchResultTyped, TableColumn as TableColumn$1, ListViewMessages, HasUnsavedChanges, TimeRangePickerLabels, TimeRangeSelection as TimeRangeSelection$1 } from '@meshmakers/shared-ui';
 import { Observable, Subject } from 'rxjs';
-import { EntitySelectDataSource, EntitySelectResult } from '@meshmakers/shared-services';
 import * as Types from '@meshmakers/octo-services';
-import { CkTypeSelectorItem, RuntimeEntityItem, RuntimeEntitySelectDataSource, RuntimeEntityDialogDataSource, SortDto, FieldFilterDto, QueryModeDto, ResolveSeriesQueryInputDto, CkRollupFunctionDto, SeriesResolutionSignalDto, AttributeItem, TenantIdProvider, TenantFeaturesStatus, HealthCheck } from '@meshmakers/octo-services';
+import { SortDto, FieldFilterDto, QueryModeDto, ResolveSeriesQueryInputDto, CkRollupFunctionDto, SeriesResolutionSignalDto, CkTypeSelectorItem, RuntimeEntityItem, RuntimeEntitySelectDataSource, RuntimeEntityDialogDataSource, AttributeItem, TenantIdProvider, TenantFeaturesStatus, HealthCheck } from '@meshmakers/octo-services';
 export { RuntimeEntityDialogDataSource, RuntimeEntityItem, RuntimeEntitySelectDataSource, TENANT_ID_PROVIDER, TenantIdProvider } from '@meshmakers/octo-services';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i1 from '@meshmakers/shared-ui';
+import { EntitySelectDialogDataSource, ColumnDefinition, DialogFetchOptions, DialogFetchResult, EntitySelectInputComponent, TimeRange, FetchDataOptions, FetchResultTyped, TableColumn as TableColumn$1, ListViewMessages, EntitySelectInputMessages, HasUnsavedChanges, TimeRangePickerLabels, TimeRangeSelection as TimeRangeSelection$1 } from '@meshmakers/shared-ui';
+import { EntitySelectDataSource, EntitySelectResult } from '@meshmakers/shared-services';
 import * as Apollo from 'apollo-angular';
 import { CkTypeSelectorInputComponent, AttributeValueTypeDto, FieldFilterItem, FilterVariable, PropertyGridItem, PropertyGridConfig, OctoGraphQlDataSource, FieldFilterEditorComponent } from '@meshmakers/octo-ui';
 import * as _meshmakers_octo_meshboard from '@meshmakers/octo-meshboard';
@@ -281,7 +281,7 @@ interface PersistentQueryDataSource extends WidgetDataSource {
     /**
      * Asset-scope binding: the `id` of an entity selector whose selection scopes
      * this widget's stream-data query. The selector resolves its picked entity to
-     * a set of source rtIds (via its `childScope` one-hop, or the picked entity
+     * a set of source rtIds (via its `childScope` hop or path, or the picked entity
      * itself when no childScope is configured); those rtIds are passed as the
      * query's `streamDataArgs.rtIds`, replacing the persisted RtIds at execution
      * time. Absent ⇒ the query runs with its persisted scope. Ignored for runtime
@@ -577,9 +577,29 @@ interface TableColumnStatusIconMapping {
     tooltip: string;
     color?: string;
 }
+/**
+ * Display label of one raw cell value of a table column (AB#7655), e.g. `{ label: 'L2' }` for `2`.
+ */
+interface TableColumnValueLabel {
+    /**
+     * Text shown instead of the raw value: one string for every language, or a text per culture
+     * code (`{ "de-AT": "gut", "en-GB": "good" }`) that follows the host language
+     * (`MESHBOARD_LANGUAGE`; exact culture, then language part). Without a match the raw value shows.
+     */
+    label: string | Record<string, string>;
+    /** Optional CSS text colour (e.g. `var(--kendo-color-success)`); without it the theme text colour applies. */
+    color?: string;
+}
 interface TableColumn {
     field: string;
+    /** Header text; the fallback when `titles` has no text for the host language. */
     title: string;
+    /**
+     * Header text per culture code (AB#7655), e.g. `{ "de-AT": "Datenqualität", "en-GB": "Data quality" }`.
+     * Picked for the host language (`MESHBOARD_LANGUAGE` / `provideMeshBoard({ language })`): exact
+     * culture, then a key equal to the language part (`de`), then `title`. No host language = `title`.
+     */
+    titles?: Record<string, string>;
     width?: number;
     dataType?: string;
     /**
@@ -589,6 +609,15 @@ interface TableColumn {
      */
     format?: string;
     statusMapping?: Record<string, TableColumnStatusIconMapping>;
+    /**
+     * Labels for raw cell values (AB#7655), keyed by the value as string (`"1"`, `"2"`, `"3"`); a
+     * number `2` and a string `"2"` both match `"2"`. The cell shows the label as plain text (with the
+     * optional colour); a value without a label keeps the column's `dataType` / `format` rendering,
+     * `null` / missing is an empty cell. When no label applies for the current language the column
+     * renders as without `valueLabels`. Wins over `MESHBOARD_LABEL_RESOLVER`. Not supported together
+     * with `statusMapping` (the labels are shown, a console warning is logged).
+     */
+    valueLabels?: Record<string, TableColumnValueLabel>;
 }
 /**
  * Gauge types available
@@ -1374,21 +1403,44 @@ interface EntitySelectorAttributeMapping {
     attributeValueType?: string;
 }
 /**
- * One-hop association traversal that turns a selected entity into the set of
- * source rtIds a stream-data widget should be scoped to.
+ * One association hop of a multi-hop child scope (AB#7723): from the entities
+ * reached so far (the picked entity for the first hop) over `roleId` in
+ * `direction` to the entities of `targetCkTypeId`.
+ */
+interface EntitySelectorScopeHop {
+    /** Association role of this hop (e.g. "System/ParentChild"). */
+    roleId: string;
+    /** Traversal direction; defaults to `'in'` (see {@link EntitySelectorChildScope.direction}). */
+    direction?: 'in' | 'out';
+    /** CK type of the entities this hop reaches; the source type of the next hop. */
+    targetCkTypeId: string;
+}
+/**
+ * Association traversal that turns a selected entity into the set of source
+ * rtIds a stream-data widget should be scoped to.
  *
  * Use case: the user picks a `MeteringPoint`, but the stream-data archive is
  * keyed by its child `EnergyMeasurement` rtIds. The childScope describes that
- * single hop (target type + association role + direction); the selected
- * entity's children of `targetCkTypeId` reached via `roleId` become the scope
- * rtIds. When a selector has no childScope, the picked entity's own rtId is the
- * scope (direct keying).
+ * hop (target type + association role + direction); the selected entity's
+ * children of `targetCkTypeId` reached via `roleId` become the scope rtIds.
+ * When a selector has no childScope, the picked entity's own rtId is the scope
+ * (direct keying).
+ *
+ * Two forms (AB#7723):
+ * - **One hop** — the top-level `targetCkTypeId` / `roleId` / `direction`. This
+ *   is the original form; the editor keeps writing one-hop scopes this way, so
+ *   older library versions keep reading them.
+ * - **Path** — `path`, an ordered list of 2 to {@link MAX_SCOPE_HOPS} hops
+ *   (A → B → C). The source type of hop n is the target type of hop n-1; the
+ *   scope is the distinct rtIds reached by the last hop. When `path` is present
+ *   (non-empty) it wins and the top-level fields are ignored; the editor then
+ *   omits them.
  */
 interface EntitySelectorChildScope {
-    /** CK type of the child entities that key the stream-data archive (e.g. EnergyMeasurement). */
-    targetCkTypeId: string;
-    /** Association role linking the selected entity to the children (e.g. "System/ParentChild"). */
-    roleId: string;
+    /** CK type of the child entities that key the stream-data archive (e.g. EnergyMeasurement). One-hop form. */
+    targetCkTypeId?: string;
+    /** Association role linking the selected entity to the children (e.g. "System/ParentChild"). One-hop form. */
+    roleId?: string;
     /**
      * Traversal direction from the selected (parent) entity to its children.
      * For `System/ParentChild` the child owns the association to its parent, so
@@ -1396,7 +1448,15 @@ interface EntitySelectorChildScope {
      * `'out'` only for custom roles modelled parent → child.
      */
     direction?: 'in' | 'out';
+    /**
+     * Ordered multi-hop path (AB#7723). Wins over the top-level fields when
+     * non-empty. At most {@link MAX_SCOPE_HOPS} hops; a longer path, or a hop
+     * without role or target type, makes the scope fail (no data plus notice).
+     */
+    path?: EntitySelectorScopeHop[];
 }
+/** Maximum number of hops of a child-scope path, enforced by editor and runtime (AB#7723). */
+declare const MAX_SCOPE_HOPS = 5;
 /**
  * Configuration for a single entity selector in the MeshBoard toolbar.
  * Each selector is bound to a CK type and populates variables from the selected entity.
@@ -1415,11 +1475,38 @@ interface EntitySelectorConfig {
     /** Optional pre-selected entity rtId */
     defaultRtId?: string;
     /**
-     * Optional one-hop traversal that resolves the picked entity to the child
-     * source rtIds a stream-data widget scopes by. Absent ⇒ the picked entity's
+     * Optional traversal (one hop, or a multi-hop `path` — AB#7723) that resolves
+     * the picked entity to the source rtIds a stream-data widget scopes by. Absent ⇒ the picked entity's
      * own rtId is the scope. See {@link EntitySelectorChildScope}.
      */
     childScope?: EntitySelectorChildScope;
+    /**
+     * Optional id of the selector this one follows (AB#7722). A follower has no
+     * picker of its own and is never written to or read from the URL: it takes
+     * the leader's current pick as its picked entity (its `ckTypeId` is the
+     * leader's) and resolves its own `childScope` and `attributeMappings` from it.
+     * Its `defaultRtId` is used only while the leader has no pick. One level only:
+     * a leader cannot itself be a follower. An unknown or chained leader is
+     * treated as "leader has no pick" (plus a console warning).
+     * See `utils/entity-selector-follow.ts`.
+     */
+    followsSelectorId?: string;
+    /**
+     * Optional picker filter (AB#7724): attribute filter rows on `ckTypeId`,
+     * combined with AND, the same type and variable substitution as widget
+     * filters (`MeshBoardVariableService.convertToFieldFilterDto`). The toolbar
+     * dropdown, its search dialog and the editor's default-entity picker send
+     * the rows as GraphQL `fieldFilter` (server side); the picker's text search
+     * is one more AND row. Absent or empty ⇒ the picker lists every entity of
+     * `ckTypeId`, as before.
+     *
+     * The filter affects the listing only: a `defaultRtId` or a URL pick that
+     * does not match is still applied (the editor warns about a non-matching
+     * `defaultRtId`). Followers have no picker; the editor writes no filter for
+     * them and a follower's filter is ignored at runtime.
+     * See `utils/entity-selector-filter.ts`.
+     */
+    filters?: WidgetFilterConfig[];
     /** Current selection (transient, not persisted) */
     selectedRtId?: string;
     /** Display name of the currently selected entity */
@@ -1760,6 +1847,315 @@ declare function isMeshBoardChrome(value: unknown): value is MeshBoardChrome;
  */
 declare function resolveMeshBoardChrome(inputChrome: unknown, routeDataChrome: unknown): MeshBoardChrome;
 
+/**
+ * Result of resolution-aware series routing (AB#4290). The caller runs the existing
+ * stream-data downsampling query against {@link archiveRtId} with `limit = points`
+ * and the column aggregation set to {@link reducingFunction}. `signal` is a truthful
+ * outcome the widget can surface (e.g. a "resolution-limited" hint).
+ *
+ * The coverage signal (AB#5157) rides the same fields: `signal` is `CoverageLimited` when the
+ * resolver's coverage filter skipped a finer rung because it holds no measured data over the
+ * requested window, `actualPoints` / `diagnostic` carry the deliverable count and the rung that
+ * was excluded, and {@link finerRungAvailableFrom} says from when that finer rung could serve.
+ */
+interface SeriesResolutionResult {
+    archiveRtId: string;
+    effectiveBucketMs: number;
+    points: number;
+    reducingFunction: CkRollupFunctionDto;
+    signal: SeriesResolutionSignalDto;
+    actualPoints: number | null;
+    diagnostic: string | null;
+    /**
+     * Earliest instant from which the coverage-excluded finer rung would be usable (AB#5157).
+     * Set only on `CoverageLimited`, null otherwise. Passed through as the wire delivers it —
+     * a `DateTime` scalar arrives as an ISO string unless a scalar parser turns it into a `Date` —
+     * so read it through `toInstant` / `formatInstant` rather than assuming either shape.
+     * Optional so that code constructing a result (mocks, adapters) written before AB#5157 keeps
+     * compiling; a missing value means the same as `null`.
+     */
+    finerRungAvailableFrom?: Date | string | null;
+}
+/**
+ * Time-range and downsampling arguments for stream-data persistent queries.
+ * Mirrors the GraphQL input `StreamDataArguments` so widgets can build it
+ * without importing generated DTO types directly.
+ *
+ * Backend semantics (verified against StreamDataQueryDtoType.cs and
+ * StreamDataVariantExecutor.cs; `queryMode` override added in AB#4233):
+ * - `from` / `to` / `limit` override the persisted query's intrinsic values
+ *   when set (`execOverride?.From ?? simple.From` pattern in the resolver).
+ * - `interval` is currently ignored by every variant; the downsampling path
+ *   derives `(to - from) / limit` itself.
+ * - `queryMode: DOWNSAMPLING` on a `SimpleSdQuery` (persisted) or the transient
+ *   `simple` sub-connection now drives the downsampling execution path: with a
+ *   full from/to/limit contract the backend reduces to `limit` buckets per series
+ *   (per-type reducers + group-by source rtId). Without all three it falls back
+ *   to raw rows. For the other variants the execution shape still comes from the
+ *   CK subtype / sub-connection; `queryMode` is a no-op there.
+ */
+interface StreamDataExecutionArgs {
+    from?: Date | null;
+    to?: Date | null;
+    interval?: number | null;
+    limit?: number | null;
+    /**
+     * `DOWNSAMPLING` switches a SimpleSdQuery / transient `simple` query to the
+     * downsampling path (with from/to/limit); a no-op for the other variants.
+     * Defaults to `Default` (raw rows).
+     */
+    queryMode?: QueryModeDto;
+    /**
+     * Source runtime ids to scope the query to. When set, replaces the persisted
+     * RtIds on the query at execution time — used to scope a stream-data widget to
+     * the entities resolved from a selected asset (e.g. the EnergyMeasurement rtIds
+     * under a picked MeteringPoint). An empty array is treated as "no scope".
+     */
+    rtIds?: string[] | null;
+}
+interface QueryExecutionOptions {
+    /** Page size — passed to the GraphQL `first` variable. */
+    first?: number | null;
+    /** Cursor — passed to the GraphQL `after` variable. */
+    after?: string | null;
+    /** Optional column / row sort definitions. */
+    sortOrder?: SortDto[] | null;
+    /** Field filters applied to the query rows. */
+    fieldFilter?: FieldFilterDto[] | null;
+    /** Stream-data-only: time-range, interval, limit, queryMode. Ignored for runtime queries. */
+    streamDataArgs?: StreamDataExecutionArgs | null;
+    /**
+     * Entity-selector scope (AB#7725): the source rtIds a widget bound to an entity
+     * selector is restricted to. Applied on the server for both families:
+     * - runtime queries (SimpleRtQuery, AggregationRtQuery, GroupingAggregationRtQuery):
+     *   adds the field filter `rtId IN (scopeRtIds)`, AND-combined with
+     *   {@link fieldFilter} and the persisted query's own filters — a grouping or
+     *   aggregation query aggregates over the scoped entities only;
+     * - stream-data queries: sent as `arg.rtIds` unless `streamDataArgs.rtIds` is set.
+     *
+     * `null`/`undefined` or an empty array means "no scope" (the query runs as saved).
+     * An empty scope must never reach the executor: callers skip the query instead
+     * (`StreamDataScope.kind === 'empty'`, AB#7721).
+     */
+    scopeRtIds?: string[] | null;
+    /** Force a network round-trip instead of using the Apollo cache. */
+    forceRefresh?: boolean;
+}
+interface QueryColumnInfo {
+    attributePath: string;
+    attributeValueType?: string | null;
+    aggregationType?: string | null;
+}
+interface QueryCell {
+    attributePath: string;
+    value: unknown;
+}
+/**
+ * Unified result-row shape across runtime and stream-data queries.
+ * `__typename` lets callers distinguish row kinds when needed
+ * (`RtSimpleQueryRow`, `RtAggregationQueryRow`, `RtGroupingAggregationQueryRow`,
+ * `StreamDataQueryRow`).
+ *
+ * Stream-data rows surface `timestamp`, `rtWellKnownName`,
+ * `rtCreationDateTime`, and `rtChangedDateTime` directly on the row — useful
+ * for time-series x-axes. Runtime rows leave those fields undefined.
+ */
+interface QueryResultRow {
+    __typename?: string;
+    rtId?: string | null;
+    ckTypeId?: string | null;
+    timestamp?: Date | null;
+    rtWellKnownName?: string | null;
+    rtCreationDateTime?: Date | null;
+    rtChangedDateTime?: Date | null;
+    cells: QueryCell[];
+}
+interface QueryExecutionResult {
+    family: QueryFamily;
+    queryRtId?: string | null;
+    associatedCkTypeId?: string | null;
+    columns: QueryColumnInfo[];
+    rows: QueryResultRow[];
+    totalCount: number;
+    hasNextPage: boolean;
+    endCursor?: string | null;
+}
+/**
+ * Executes persistent queries by rtId and returns a unified result shape
+ * regardless of whether the underlying query is runtime-data or stream-data.
+ *
+ * Widgets consume `QueryExecutionResult` and stay agnostic about which family
+ * the saved query belongs to — switching a widget's data source between
+ * runtime and stream-data is purely a configuration change.
+ */
+declare class QueryExecutorService {
+    private readonly runtimeGql;
+    private readonly streamDataGql;
+    private readonly persistentQueriesGql;
+    private readonly resolveSeriesGql;
+    private readonly queryArchiveGql;
+    private readonly downsampleGql;
+    private readonly entitiesGql;
+    private readonly secretSafeNames;
+    /**
+     * Cache of resolved query families, keyed by query rtId. Filled lazily for
+     * legacy widget configs that pre-date the `queryFamily` field — saves a
+     * round-trip on every refresh.
+     */
+    private readonly familyCache;
+    execute(family: QueryFamily | undefined, queryRtId: string, options?: QueryExecutionOptions): Observable<QueryExecutionResult>;
+    /**
+     * Resolves the family of a persistent query by rtId. Falls back to
+     * `'runtime'` when the query type cannot be classified — this matches the
+     * pre-Phase-1 behavior.
+     */
+    resolveFamily(queryRtId: string): Promise<QueryFamily>;
+    executeRuntime(queryRtId: string, options?: QueryExecutionOptions): Observable<QueryExecutionResult>;
+    executeStreamData(queryRtId: string, options?: QueryExecutionOptions): Observable<QueryExecutionResult>;
+    /**
+     * Resolution-aware series routing (AB#4290): asks the backend which archive/rollup to
+     * query for a base archive family, time window and target point count — so a widget can
+     * render ~`targetPoints` points without knowing which physical archive holds the data at a
+     * usable grain. The caller then runs {@link executeStreamData} (downsampling) against the
+     * returned `archiveRtId` with `limit = points`. Returns null when StreamData is not enabled.
+     */
+    resolveSeriesQuery(input: ResolveSeriesQueryInputDto): Promise<SeriesResolutionResult | null>;
+    /**
+     * Resolution-aware routing (AB#4290): reads a persisted stream-data query's base archive rtId
+     * and target CK type WITHOUT executing the query (the `rows` sub-connection is not selected), so
+     * a widget can feed the archive to {@link resolveSeriesQuery} and use the CK type to resolve
+     * per-series labels. Also reads the query's persisted RtIds pin
+     * (`System/StreamDataQuery.RtIds`) from the runtime entity — the transient downsampling path
+     * bypasses the persisted query execution, so widgets must re-apply the pin themselves
+     * (AB#4818). `rtIds` is null when the query has no pin (or is not a SimpleSdQuery).
+     * Returns null when the query is missing or has no archive.
+     */
+    fetchQueryArchive(queryRtId: string): Promise<{
+        archiveRtId: string;
+        ckTypeId: string | null;
+        rtIds: string[] | null;
+    } | null>;
+    /**
+     * Resolution-aware routing (AB#4290): runs the AB#4233 downsampling query against an explicit
+     * archive rtId (the rollup/base chosen by {@link resolveSeriesQuery}), reducing `sourcePath`
+     * with `aggregation` to at most `limit` buckets. The transient downsampling groups by bin
+     * (not by source rtId), so callers that need per-series lines scope `rtIds` to one source
+     * entity per call. Returns the unified rows; each row's single value cell carries the reduced
+     * value under its wire column name (e.g. `amountvalue_sum`) alongside the bin `timestamp`.
+     */
+    downsampleByArchive(params: {
+        archiveRtId: string;
+        from: Date;
+        to: Date;
+        limit: number;
+        sourcePath: string;
+        aggregation: string;
+        rtIds?: string[] | null;
+        fieldFilter?: FieldFilterDto[] | null;
+    }): Promise<QueryResultRow[]>;
+    /**
+     * Best-effort per-series labels for resolution-aware fan-out (AB#4290): reads each source
+     * entity's attribute matching `labelField` (canonical, case/underscore-insensitive so an archive
+     * column name maps to its CK attribute). Entities that fail to load or lack the attribute are
+     * simply omitted; the caller falls back to the rtId. Returns a `rtId → label` map.
+     */
+    fetchSeriesLabels(ckTypeId: string, rtIds: string[], labelField: string): Promise<Map<string, string>>;
+    /**
+     * The non-secret attribute names of `ckTypeId` whose canonical form matches `wanted`
+     * (SECRET-safe explicit list, AB#5542). Empty when nothing matches — the caller then falls back
+     * as for a missing attribute.
+     */
+    private matchingAttributeNames;
+    /** Cap on the source-entity population read for group-aggregation (AB#4714). A truncated read is
+     *  logged, never silent. */
+    private static readonly ENTITY_GROUP_FETCH_CAP;
+    /**
+     * Group-aggregation source resolution (AB#4714): fetches the source entities of `ckTypeId` in a
+     * single bulk read and buckets their rtIds by the value of `groupField` (canonical match — case
+     * and non-alphanumerics are ignored, so an archive column name maps to its CK attribute). Returns
+     * `groupValue → rtIds`. Optionally restricted to `restrictRtIds` (an entity-selector scope) —
+     * entities outside that set are dropped. Entities whose group attribute is missing/null are
+     * omitted (they cannot be attributed to a line). The population is bounded to
+     * {@link ENTITY_GROUP_FETCH_CAP}; a truncated read is logged (never silently capped).
+     */
+    fetchEntityGroups(ckTypeId: string, groupField: string, restrictRtIds?: string[]): Promise<Map<string, string[]>>;
+    /**
+     * Runtime entity-selector scope (AB#7725): appends `rtId IN (scopeRtIds)` to the
+     * caller's field filters. The backend AND-combines all runtime field filters with
+     * the persisted query's filters before the database query, so simple rows as well
+     * as aggregation / grouping results cover the scoped entities only. Returns the
+     * caller's filters unchanged (or `undefined`) when there is no scope.
+     */
+    static withRtIdScope(fieldFilter: FieldFilterDto[] | null | undefined, scopeRtIds: string[] | null | undefined): FieldFilterDto[] | undefined;
+    /** Stream-data entity-selector scope: `scopeRtIds` fill `rtIds` unless the caller set them. */
+    private static withStreamDataScope;
+    private buildStreamDataArg;
+    private mapColumns;
+    private mapRuntimeRows;
+    private mapStreamDataRows;
+    private mapCells;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryExecutorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<QueryExecutorService>;
+}
+
+/**
+ * Resolution state of one entity selector's stream-data scope (AB#7721). Kept
+ * transiently by `MeshBoardStateService`, written by the view while a pick is
+ * resolved to its source rtIds.
+ *
+ * - `pending`: the pick is being resolved (childScope traversal, one hop or a path).
+ * - `resolved`: the pick resolved to `rtIds` — possibly none.
+ * - `failed`: the resolution threw (e.g. the association fetch failed).
+ *
+ * A selector without an entry has no active pick: bound widgets keep the
+ * query's persisted scope.
+ */
+type EntitySelectorScopeState = {
+    status: 'pending';
+} | {
+    status: 'resolved';
+    rtIds: string[];
+} | {
+    status: 'failed';
+};
+/**
+ * What a widget bound to an entity selector does with its persistent query —
+ * stream data (AB#7721) and runtime queries (AB#7725). Returned by
+ * `MeshBoardStateService.resolveEntitySelectorScope`.
+ *
+ * - `unscoped`: no binding or no active pick — query with the persisted scope
+ *   (unchanged behaviour).
+ * - `pending`: the scope is still resolving — show the loading state and send
+ *   NO query; the view triggers a refresh once the scope is known.
+ * - `scoped`: query restricted to `rtIds` on the server — stream data via
+ *   `streamDataArgs.rtIds`, runtime queries (simple, aggregation, grouping) via
+ *   the field filter `rtId IN (rtIds)` (`QueryExecutionOptions.scopeRtIds`).
+ * - `empty`: the pick has nothing in scope (`noTargets`) or the lookup failed
+ *   (`failed`) — show the no-data state and send NO query. Never fall back to
+ *   the persisted scope: that would show rows of other entities.
+ *   `invalidTimeRange` (AB#7582): the embedding host set a `timeRange` that is
+ *   unparseable or empty (`from >= to`) — every stream-data query bound to the
+ *   time filter is skipped, whatever its selector binding; a widget with
+ *   `ignoreTimeFilter` is not affected.
+ */
+type StreamDataScope = {
+    kind: 'unscoped';
+} | {
+    kind: 'pending';
+} | {
+    kind: 'scoped';
+    rtIds: string[];
+} | {
+    kind: 'empty';
+    reason: 'noTargets' | 'failed' | 'invalidTimeRange';
+};
+/**
+ * The result a widget renders instead of executing its query when its scope is
+ * `empty` (AB#7721). Shape-compatible with a real empty response, so each
+ * widget's existing no-data rendering applies unchanged.
+ */
+declare function emptyQueryExecutionResult(family: QueryFamily | undefined): QueryExecutionResult;
+
 type GetSystemPersistentQueriesQueryVariablesDto = Types.Exact<{
     after?: Types.InputMaybe<Types.Scalars['String']['input']>;
     first?: Types.InputMaybe<Types.Scalars['Int']['input']>;
@@ -2136,6 +2532,20 @@ declare class MeshBoardPersistenceService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<MeshBoardPersistenceService>;
 }
 
+/**
+ * The period an embedding host sets on the board (AB#7582): two exact instants
+ * (half-open `[from, to)`), or `invalid` (with the reason) when the host passed an
+ * unparseable or empty range. Produced by `parseHostTimeRange`, held transiently by
+ * {@link MeshBoardStateService.setHostTimeRange}.
+ */
+type HostTimeRangeState = {
+    status: 'valid';
+    from: Date;
+    to: Date;
+} | {
+    status: 'invalid';
+    reason: string;
+};
 /**
  * Service that manages MeshBoard state and persistence.
  * Coordinates loading, saving, and switching between MeshBoards.
@@ -2154,12 +2564,20 @@ declare class MeshBoardStateService {
     private readonly _isModelAvailable;
     private readonly _variableResolutionErrors;
     /**
-     * Transient cache of the source rtIds resolved from each entity selector's
-     * current selection (keyed by selector id). Populated by the view component
-     * when a selection resolves (one-hop childScope traversal, or the picked
-     * entity's own rtId). Not persisted — derived fresh from each selection.
+     * Transient scope state of each entity selector's current selection (keyed
+     * by selector id): `pending` while the view resolves the pick, `resolved`
+     * with the source rtIds (childScope hop or path, or the picked entity's
+     * own rtId; possibly none), or `failed`. No entry = no active pick. Not
+     * persisted — derived fresh from each selection, cleared on board switch
+     * (AB#7721).
      */
-    private readonly _entitySelectorRtIds;
+    private readonly _entitySelectorScopes;
+    /**
+     * Period set by the page that embeds the board (`MeshBoardViewComponent.timeRange`, AB#7582):
+     * exact instants, or `invalid` when the host passed an unusable range. `null` = the board's own
+     * selection applies. Transient — never persisted, never written into the board config.
+     */
+    private readonly _hostTimeRange;
     /**
      * Transient variables published by widgets (KPI output variables, AB#5364).
      * Kept apart from `_meshBoardConfig` so publishing triggers no persistence and
@@ -2411,6 +2829,11 @@ declare class MeshBoardStateService {
      * Boundaries are resolved on the board's {@link timeZoneMode} basis (local by
      * default, or UTC), the same basis widgets format their datetime display on —
      * so the selected range and the displayed timestamps stay consistent.
+     *
+     * While an embedding host has set a period ({@link setHostTimeRange}, AB#7582)
+     * and the board's time filter is enabled, the host's instants are returned
+     * unchanged (no day snapping, no zone conversion) and the stored selection is
+     * ignored; an invalid host period resolves to `null`.
      */
     resolveCurrentTimeRange(): TimeRange | null;
     /**
@@ -2441,25 +2864,104 @@ declare class MeshBoardStateService {
      * for (AB#5157 review). `undefined` now only means the browser named no zone at all.
      */
     resolveStreamDataTimeZone(): string | undefined;
+    /**
+     * Marks an entity selector's scope as being resolved (AB#7721). Bound
+     * stream-data widgets show their loading state and send no query until the
+     * scope is resolved, failed or cleared — so they never flash rows of the
+     * query's persisted (unscoped) scope while a pick is resolving.
+     */
+    setEntitySelectorScopePending(selectorId: string): void;
     /**
      * Stores the source rtIds resolved from an entity selector's current
      * selection. Called by the view component after a selection resolves (the
-     * one-hop childScope traversal, or the picked entity's own rtId when the
-     * selector has no childScope). Transient — not persisted.
+     * childScope traversal (one hop or a path), or the picked entity's own rtId when the
+     * selector has no childScope). An empty array is a resolved EMPTY scope:
+     * bound widgets show no data and send no query (AB#7721). Transient — not
+     * persisted.
      */
     setEntitySelectorRtIds(selectorId: string, rtIds: string[]): void;
     /**
-     * Clears the cached source rtIds for an entity selector (e.g. when its
-     * selection is cleared).
+     * Marks an entity selector's scope resolution as failed (e.g. the association
+     * fetch threw). Bound widgets treat it like an empty scope — no data, no
+     * query — and the view tells the user the scope could not be resolved
+     * (AB#7721).
+     */
+    setEntitySelectorScopeFailed(selectorId: string): void;
+    /**
+     * Clears the scope state for an entity selector (its selection was cleared).
+     * Bound widgets then query with the persisted scope again.
      */
     clearEntitySelectorRtIds(selectorId: string): void;
+    /** The raw scope state of a selector, or `undefined` when it has no active pick. */
+    getEntitySelectorScopeState(selectorId: string): EntitySelectorScopeState | undefined;
     /**
-     * Resolves the stream-data `rtIds` scope for a persistent-query widget bound
-     * to an entity selector. Returns the source rtIds cached from the selector's
-     * current selection, or `undefined` when the selector id is absent, unknown,
-     * or has no active selection (so the query keeps its persisted scope).
+     * Ids of the selectors whose scope resolution failed (for the view's
+     * "could not resolve the scope" notice, AB#7721).
+     */
+    readonly failedEntitySelectorScopeIds: _angular_core.Signal<string[]>;
+    /**
+     * Decides how a widget runs its persistent query — the entry point every
+     * built-in widget calls with its binding, query family and time-filter opt-out:
+     *
+     * 1. Host gate (AB#7582): while the embedding host's period is invalid, every
+     *    stream-data query bound to the time filter is `empty` (`invalidTimeRange`),
+     *    whatever its selector binding; pass the widget's `ignoreTimeFilter` so an
+     *    opted-out widget, whose data does not depend on the period, keeps querying.
+     *    Runtime queries have no time window and are not gated. A legacy config
+     *    without `queryFamily` is treated as stream data here.
+     * 2. Entity-selector scope ({@link resolveEntitySelectorScope}, AB#7721) — since
+     *    AB#7725 for runtime queries too: `unscoped` / `pending` / `scoped` / `empty`.
+     */
+    resolveStreamDataScope(entitySelectorId?: string, family?: QueryFamily, ignoreTimeFilter?: boolean): StreamDataScope;
+    /**
+     * The entity-selector part of {@link resolveStreamDataScope}, without the host
+     * gate — stream data (AB#7721) and runtime queries alike (AB#7725):
+     *
+     * - `unscoped` — no binding, or no active pick: keep the query as saved.
+     * - `pending` — the pick is still resolving: show loading, send no query.
+     * - `scoped` — query restricted to the resolved rtIds: stream data via
+     *   `streamDataArgs.rtIds`, runtime queries via the `rtId IN` field filter
+     *   (`QueryExecutionOptions.scopeRtIds`).
+     * - `empty` — the pick has nothing in scope or the lookup failed: show the
+     *   no-data state and send no query. Never fall back to the persisted scope.
+     */
+    resolveEntitySelectorScope(entitySelectorId?: string): StreamDataScope;
+    /**
+     * Resolves the stream-data `rtIds` for a persistent-query widget bound to an
+     * entity selector: the resolved source rtIds when the scope is `scoped`,
+     * otherwise `undefined`.
+     *
+     * `undefined` does NOT mean "query with the persisted scope" for a pending or
+     * empty scope — callers must check {@link resolveStreamDataScope} first and
+     * skip the query for `pending` / `empty` (AB#7721).
      */
     resolveStreamDataRtIds(entitySelectorId?: string): string[] | undefined;
+    private setEntitySelectorScope;
+    /**
+     * Sets (or with `null` clears) the period of the page embedding the board
+     * (AB#7582). Called by `MeshBoardViewComponent` for its `timeRange` input; a
+     * host normally sets the input instead of calling this. Transient: not
+     * persisted, not written into the board config, so it never causes unsaved
+     * changes. Only takes effect while the board's time filter is enabled.
+     */
+    setHostTimeRange(state: HostTimeRangeState | null, owner?: object): void;
+    /**
+     * Clears the host period only if `owner` set it (AB#7582). The service is
+     * root-provided, so a view that is destroyed (or drops its `timeRange`) must not
+     * clear a period another view set in the meantime.
+     */
+    clearHostTimeRange(owner: object): void;
+    /** The view (or other caller) that set the current host period, if it said so. */
+    private hostTimeRangeOwner;
+    /** The period set by the embedding host, or `null` when the board's own selection applies. */
+    readonly hostTimeRange: _angular_core.Signal<HostTimeRangeState | null>;
+    /**
+     * True when an invalid host period blocks a stream-data query that is bound to
+     * the time filter (AB#7582): the period is invalid, the board's time filter is
+     * enabled and the caller did not opt out with `ignoreTimeFilter`. Such a query
+     * must not be sent — without a window it would read the whole archive.
+     */
+    isStreamDataBlockedByHostTimeRange(ignoreTimeFilter?: boolean): boolean;
     /**
      * Updates the time filter configuration.
      */
@@ -2561,12 +3063,17 @@ interface RepeaterDataItem {
     /** All attributes as a Map for easy access */
     attributes: Map<string, unknown>;
 }
+/** Source rtIds per request of one batched association hop (AB#7723). */
+declare const ASSOCIATION_HOP_SOURCE_BATCH = 100;
+/** Targets read per source entity in one association hop (AB#7723). */
+declare const ASSOCIATION_HOP_TARGETS_PER_SOURCE = 1000;
 declare class MeshBoardDataService {
     private readonly getDashboardEntityGQL;
     private readonly getCkModelsWithStateGQL;
     private readonly getEntitiesByCkTypeGQL;
     private readonly queryExecutor;
     private readonly getAssociationTargetsGQL;
+    private readonly getAssociationTargetRtIdsGQL;
     private readonly secretSafeNames;
     private readonly getCkTypeAttributesGQL;
     private readonly apollo;
@@ -2649,6 +3156,20 @@ declare class MeshBoardDataService {
      * Uses the associations.targets() GraphQL endpoint.
      */
     fetchAssociationTargets(sourceRtId: string, sourceCkTypeId: string, targetCkTypeId: string, roleId: string, direction: 'in' | 'out', attributeNames?: string[], first?: number): Observable<TargetEntityWithAttributes[]>;
+    /**
+     * One association hop for MANY source entities (AB#7723, multi-hop child
+     * scope): the rtIds of the `targetCkTypeId` entities reached from each of
+     * `sourceRtIds` (all of `sourceCkTypeId`) over `roleId` in `direction`.
+     *
+     * Query cost: the sources go out in batches of
+     * {@link ASSOCIATION_HOP_SOURCE_BATCH} rtIds per request (`runtimeEntities(rtIds:)`
+     * with the association targets nested), the batches of one hop in parallel —
+     * never one request per entity. Only rtIds are selected. Per source at most
+     * {@link ASSOCIATION_HOP_TARGETS_PER_SOURCE} targets are read; a truncated
+     * source is logged as a warning. Duplicates are not removed here.
+     * Errors propagate (the caller turns them into a failed scope).
+     */
+    fetchAssociationTargetRtIds(sourceRtIds: readonly string[], sourceCkTypeId: string, targetCkTypeId: string, roleId: string, direction: 'in' | 'out'): Observable<string[]>;
     /**
      * Fetches CK type attribute definitions (name + type) for config dialog.
      */
@@ -3000,301 +3521,74 @@ declare class EditModeStateService {
     getSnapshot<T>(): T | null;
     /**
      * Updates the snapshot with new data while staying in edit mode.
-     * Useful when you want to update the "base" state during editing.
-     */
-    updateSnapshot<T>(data: T): void;
-    /**
-     * Resets all state (useful for cleanup).
-     */
-    reset(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditModeStateService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EditModeStateService>;
-}
-
-interface GridCell {
-    col: number;
-    row: number;
-}
-interface GridPosition {
-    col: number;
-    row: number;
-}
-/**
- * Service for MeshBoard grid layout calculations and collision detection.
- * Handles widget positioning, overlap detection, and finding available positions.
- */
-declare class MeshBoardGridService {
-    /**
-     * Returns all grid cells occupied by a widget at the given position/size.
-     */
-    getCells(col: number, row: number, colSpan: number, rowSpan: number): GridCell[];
-    /**
-     * Checks if placing a widget at the given position/size would overlap with any other widget.
-     * Uses the model (not DOM) for accurate, predictable collision detection.
-     */
-    wouldCauseOverlap(widgets: AnyWidgetConfig[], widgetId: string, col: number, row: number, colSpan: number, rowSpan: number): boolean;
-    /**
-     * Checks if a widget would extend beyond the grid boundaries.
-     */
-    isOutOfBounds(col: number, colSpan: number, maxColumns: number): boolean;
-    /**
-     * Finds an available position for a widget of the given size.
-     */
-    findAvailablePosition(widgets: AnyWidgetConfig[], colSpan: number, rowSpan: number, maxColumns: number): GridPosition;
-    /**
-     * Resolves overlapping widgets by moving them to non-overlapping positions.
-     * Modifies the widgets array in place.
-     * Returns the list of widgets that were moved.
-     */
-    resolveOverlaps(widgets: AnyWidgetConfig[], maxColumns: number): AnyWidgetConfig[];
-    /**
-     * Gets all widgets that would be outside the grid if columns were reduced.
-     */
-    getWidgetsOutOfBounds(widgets: AnyWidgetConfig[], newColumns: number): AnyWidgetConfig[];
-    /**
-     * Calculates the maximum row used by any widget.
-     */
-    getMaxRow(widgets: AnyWidgetConfig[]): number;
-    /**
-     * Creates a set of all occupied cell keys from the widgets.
-     */
-    private getOccupiedCells;
-    /**
-     * Finds an available position using a pre-computed set of occupied cells.
-     */
-    private findAvailablePositionWithOccupied;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardGridService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MeshBoardGridService>;
-}
-/** @deprecated Use MeshBoardGridService instead */
-declare const DashboardGridService: typeof MeshBoardGridService;
-
-/**
- * Result of resolution-aware series routing (AB#4290). The caller runs the existing
- * stream-data downsampling query against {@link archiveRtId} with `limit = points`
- * and the column aggregation set to {@link reducingFunction}. `signal` is a truthful
- * outcome the widget can surface (e.g. a "resolution-limited" hint).
- *
- * The coverage signal (AB#5157) rides the same fields: `signal` is `CoverageLimited` when the
- * resolver's coverage filter skipped a finer rung because it holds no measured data over the
- * requested window, `actualPoints` / `diagnostic` carry the deliverable count and the rung that
- * was excluded, and {@link finerRungAvailableFrom} says from when that finer rung could serve.
- */
-interface SeriesResolutionResult {
-    archiveRtId: string;
-    effectiveBucketMs: number;
-    points: number;
-    reducingFunction: CkRollupFunctionDto;
-    signal: SeriesResolutionSignalDto;
-    actualPoints: number | null;
-    diagnostic: string | null;
-    /**
-     * Earliest instant from which the coverage-excluded finer rung would be usable (AB#5157).
-     * Set only on `CoverageLimited`, null otherwise. Passed through as the wire delivers it —
-     * a `DateTime` scalar arrives as an ISO string unless a scalar parser turns it into a `Date` —
-     * so read it through `toInstant` / `formatInstant` rather than assuming either shape.
-     * Optional so that code constructing a result (mocks, adapters) written before AB#5157 keeps
-     * compiling; a missing value means the same as `null`.
-     */
-    finerRungAvailableFrom?: Date | string | null;
-}
-/**
- * Time-range and downsampling arguments for stream-data persistent queries.
- * Mirrors the GraphQL input `StreamDataArguments` so widgets can build it
- * without importing generated DTO types directly.
- *
- * Backend semantics (verified against StreamDataQueryDtoType.cs and
- * StreamDataVariantExecutor.cs; `queryMode` override added in AB#4233):
- * - `from` / `to` / `limit` override the persisted query's intrinsic values
- *   when set (`execOverride?.From ?? simple.From` pattern in the resolver).
- * - `interval` is currently ignored by every variant; the downsampling path
- *   derives `(to - from) / limit` itself.
- * - `queryMode: DOWNSAMPLING` on a `SimpleSdQuery` (persisted) or the transient
- *   `simple` sub-connection now drives the downsampling execution path: with a
- *   full from/to/limit contract the backend reduces to `limit` buckets per series
- *   (per-type reducers + group-by source rtId). Without all three it falls back
- *   to raw rows. For the other variants the execution shape still comes from the
- *   CK subtype / sub-connection; `queryMode` is a no-op there.
- */
-interface StreamDataExecutionArgs {
-    from?: Date | null;
-    to?: Date | null;
-    interval?: number | null;
-    limit?: number | null;
-    /**
-     * `DOWNSAMPLING` switches a SimpleSdQuery / transient `simple` query to the
-     * downsampling path (with from/to/limit); a no-op for the other variants.
-     * Defaults to `Default` (raw rows).
-     */
-    queryMode?: QueryModeDto;
-    /**
-     * Source runtime ids to scope the query to. When set, replaces the persisted
-     * RtIds on the query at execution time — used to scope a stream-data widget to
-     * the entities resolved from a selected asset (e.g. the EnergyMeasurement rtIds
-     * under a picked MeteringPoint). An empty array is treated as "no scope".
-     */
-    rtIds?: string[] | null;
-}
-interface QueryExecutionOptions {
-    /** Page size — passed to the GraphQL `first` variable. */
-    first?: number | null;
-    /** Cursor — passed to the GraphQL `after` variable. */
-    after?: string | null;
-    /** Optional column / row sort definitions. */
-    sortOrder?: SortDto[] | null;
-    /** Field filters applied to the query rows. */
-    fieldFilter?: FieldFilterDto[] | null;
-    /** Stream-data-only: time-range, interval, limit, queryMode. Ignored for runtime queries. */
-    streamDataArgs?: StreamDataExecutionArgs | null;
-    /** Force a network round-trip instead of using the Apollo cache. */
-    forceRefresh?: boolean;
-}
-interface QueryColumnInfo {
-    attributePath: string;
-    attributeValueType?: string | null;
-    aggregationType?: string | null;
-}
-interface QueryCell {
-    attributePath: string;
-    value: unknown;
-}
-/**
- * Unified result-row shape across runtime and stream-data queries.
- * `__typename` lets callers distinguish row kinds when needed
- * (`RtSimpleQueryRow`, `RtAggregationQueryRow`, `RtGroupingAggregationQueryRow`,
- * `StreamDataQueryRow`).
- *
- * Stream-data rows surface `timestamp`, `rtWellKnownName`,
- * `rtCreationDateTime`, and `rtChangedDateTime` directly on the row — useful
- * for time-series x-axes. Runtime rows leave those fields undefined.
- */
-interface QueryResultRow {
-    __typename?: string;
-    rtId?: string | null;
-    ckTypeId?: string | null;
-    timestamp?: Date | null;
-    rtWellKnownName?: string | null;
-    rtCreationDateTime?: Date | null;
-    rtChangedDateTime?: Date | null;
-    cells: QueryCell[];
+     * Useful when you want to update the "base" state during editing.
+     */
+    updateSnapshot<T>(data: T): void;
+    /**
+     * Resets all state (useful for cleanup).
+     */
+    reset(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditModeStateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EditModeStateService>;
 }
-interface QueryExecutionResult {
-    family: QueryFamily;
-    queryRtId?: string | null;
-    associatedCkTypeId?: string | null;
-    columns: QueryColumnInfo[];
-    rows: QueryResultRow[];
-    totalCount: number;
-    hasNextPage: boolean;
-    endCursor?: string | null;
+
+interface GridCell {
+    col: number;
+    row: number;
+}
+interface GridPosition {
+    col: number;
+    row: number;
 }
 /**
- * Executes persistent queries by rtId and returns a unified result shape
- * regardless of whether the underlying query is runtime-data or stream-data.
- *
- * Widgets consume `QueryExecutionResult` and stay agnostic about which family
- * the saved query belongs to — switching a widget's data source between
- * runtime and stream-data is purely a configuration change.
+ * Service for MeshBoard grid layout calculations and collision detection.
+ * Handles widget positioning, overlap detection, and finding available positions.
  */
-declare class QueryExecutorService {
-    private readonly runtimeGql;
-    private readonly streamDataGql;
-    private readonly persistentQueriesGql;
-    private readonly resolveSeriesGql;
-    private readonly queryArchiveGql;
-    private readonly downsampleGql;
-    private readonly entitiesGql;
-    private readonly secretSafeNames;
+declare class MeshBoardGridService {
     /**
-     * Cache of resolved query families, keyed by query rtId. Filled lazily for
-     * legacy widget configs that pre-date the `queryFamily` field — saves a
-     * round-trip on every refresh.
+     * Returns all grid cells occupied by a widget at the given position/size.
      */
-    private readonly familyCache;
-    execute(family: QueryFamily | undefined, queryRtId: string, options?: QueryExecutionOptions): Observable<QueryExecutionResult>;
+    getCells(col: number, row: number, colSpan: number, rowSpan: number): GridCell[];
     /**
-     * Resolves the family of a persistent query by rtId. Falls back to
-     * `'runtime'` when the query type cannot be classified — this matches the
-     * pre-Phase-1 behavior.
+     * Checks if placing a widget at the given position/size would overlap with any other widget.
+     * Uses the model (not DOM) for accurate, predictable collision detection.
      */
-    resolveFamily(queryRtId: string): Promise<QueryFamily>;
-    executeRuntime(queryRtId: string, options?: QueryExecutionOptions): Observable<QueryExecutionResult>;
-    executeStreamData(queryRtId: string, options?: QueryExecutionOptions): Observable<QueryExecutionResult>;
+    wouldCauseOverlap(widgets: AnyWidgetConfig[], widgetId: string, col: number, row: number, colSpan: number, rowSpan: number): boolean;
     /**
-     * Resolution-aware series routing (AB#4290): asks the backend which archive/rollup to
-     * query for a base archive family, time window and target point count — so a widget can
-     * render ~`targetPoints` points without knowing which physical archive holds the data at a
-     * usable grain. The caller then runs {@link executeStreamData} (downsampling) against the
-     * returned `archiveRtId` with `limit = points`. Returns null when StreamData is not enabled.
+     * Checks if a widget would extend beyond the grid boundaries.
      */
-    resolveSeriesQuery(input: ResolveSeriesQueryInputDto): Promise<SeriesResolutionResult | null>;
+    isOutOfBounds(col: number, colSpan: number, maxColumns: number): boolean;
     /**
-     * Resolution-aware routing (AB#4290): reads a persisted stream-data query's base archive rtId
-     * and target CK type WITHOUT executing the query (the `rows` sub-connection is not selected), so
-     * a widget can feed the archive to {@link resolveSeriesQuery} and use the CK type to resolve
-     * per-series labels. Also reads the query's persisted RtIds pin
-     * (`System/StreamDataQuery.RtIds`) from the runtime entity — the transient downsampling path
-     * bypasses the persisted query execution, so widgets must re-apply the pin themselves
-     * (AB#4818). `rtIds` is null when the query has no pin (or is not a SimpleSdQuery).
-     * Returns null when the query is missing or has no archive.
+     * Finds an available position for a widget of the given size.
      */
-    fetchQueryArchive(queryRtId: string): Promise<{
-        archiveRtId: string;
-        ckTypeId: string | null;
-        rtIds: string[] | null;
-    } | null>;
+    findAvailablePosition(widgets: AnyWidgetConfig[], colSpan: number, rowSpan: number, maxColumns: number): GridPosition;
     /**
-     * Resolution-aware routing (AB#4290): runs the AB#4233 downsampling query against an explicit
-     * archive rtId (the rollup/base chosen by {@link resolveSeriesQuery}), reducing `sourcePath`
-     * with `aggregation` to at most `limit` buckets. The transient downsampling groups by bin
-     * (not by source rtId), so callers that need per-series lines scope `rtIds` to one source
-     * entity per call. Returns the unified rows; each row's single value cell carries the reduced
-     * value under its wire column name (e.g. `amountvalue_sum`) alongside the bin `timestamp`.
+     * Resolves overlapping widgets by moving them to non-overlapping positions.
+     * Modifies the widgets array in place.
+     * Returns the list of widgets that were moved.
      */
-    downsampleByArchive(params: {
-        archiveRtId: string;
-        from: Date;
-        to: Date;
-        limit: number;
-        sourcePath: string;
-        aggregation: string;
-        rtIds?: string[] | null;
-        fieldFilter?: FieldFilterDto[] | null;
-    }): Promise<QueryResultRow[]>;
+    resolveOverlaps(widgets: AnyWidgetConfig[], maxColumns: number): AnyWidgetConfig[];
     /**
-     * Best-effort per-series labels for resolution-aware fan-out (AB#4290): reads each source
-     * entity's attribute matching `labelField` (canonical, case/underscore-insensitive so an archive
-     * column name maps to its CK attribute). Entities that fail to load or lack the attribute are
-     * simply omitted; the caller falls back to the rtId. Returns a `rtId → label` map.
+     * Gets all widgets that would be outside the grid if columns were reduced.
      */
-    fetchSeriesLabels(ckTypeId: string, rtIds: string[], labelField: string): Promise<Map<string, string>>;
+    getWidgetsOutOfBounds(widgets: AnyWidgetConfig[], newColumns: number): AnyWidgetConfig[];
     /**
-     * The non-secret attribute names of `ckTypeId` whose canonical form matches `wanted`
-     * (SECRET-safe explicit list, AB#5542). Empty when nothing matches — the caller then falls back
-     * as for a missing attribute.
+     * Calculates the maximum row used by any widget.
      */
-    private matchingAttributeNames;
-    /** Cap on the source-entity population read for group-aggregation (AB#4714). A truncated read is
-     *  logged, never silent. */
-    private static readonly ENTITY_GROUP_FETCH_CAP;
+    getMaxRow(widgets: AnyWidgetConfig[]): number;
     /**
-     * Group-aggregation source resolution (AB#4714): fetches the source entities of `ckTypeId` in a
-     * single bulk read and buckets their rtIds by the value of `groupField` (canonical match — case
-     * and non-alphanumerics are ignored, so an archive column name maps to its CK attribute). Returns
-     * `groupValue → rtIds`. Optionally restricted to `restrictRtIds` (an entity-selector scope) —
-     * entities outside that set are dropped. Entities whose group attribute is missing/null are
-     * omitted (they cannot be attributed to a line). The population is bounded to
-     * {@link ENTITY_GROUP_FETCH_CAP}; a truncated read is logged (never silently capped).
+     * Creates a set of all occupied cell keys from the widgets.
      */
-    fetchEntityGroups(ckTypeId: string, groupField: string, restrictRtIds?: string[]): Promise<Map<string, string[]>>;
-    private buildStreamDataArg;
-    private mapColumns;
-    private mapRuntimeRows;
-    private mapStreamDataRows;
-    private mapCells;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryExecutorService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<QueryExecutorService>;
+    private getOccupiedCells;
+    /**
+     * Finds an available position using a pre-computed set of occupied cells.
+     */
+    private findAvailablePositionWithOccupied;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardGridService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MeshBoardGridService>;
 }
+/** @deprecated Use MeshBoardGridService instead */
+declare const DashboardGridService: typeof MeshBoardGridService;
 
 /**
  * Manages a `setInterval` lifecycle for MeshBoard auto-refresh.
@@ -4026,17 +4320,34 @@ declare class TableWidgetComponent implements DashboardWidget<TableWidgetConfig,
     dataSource?: TableWidgetDataSourceDirective;
     private readonly stateService;
     /** Host texts (`MESHBOARD_MESSAGES`, AB#5622): list texts (empty state, pager, toolbar) and the placeholder. */
-    protected readonly texts: _angular_core.Signal<_meshmakers_octo_meshboard.MeshBoardMessages & Required<Omit<_meshmakers_octo_meshboard.MeshBoardMessages, "tableList">>>;
+    protected readonly texts: Signal<_meshmakers_octo_meshboard.MeshBoardMessages & Required<Omit<_meshmakers_octo_meshboard.MeshBoardMessages, "tableList">>>;
     /** Host translation of enum cell values (`MESHBOARD_LABEL_RESOLVER`, AB#5622); absent = raw text. */
     private readonly labelResolver;
     /** CK value type per derived column field (persistent queries), for the label resolver. */
     private readonly _queryColumnValueTypes;
+    /** Host UI language (`MESHBOARD_LANGUAGE`, AB#7655) for column `titles` / `valueLabels`; `null` = `title` / raw texts. */
+    private readonly language;
+    /**
+     * Problems already warned about (`<widget id or instance>|<field>|<problem hash>`), so a bad config
+     * logs once, not on every language change, while a new problem after a config edit is reported again.
+     */
+    private readonly warnedColumns;
+    /** Fallback warning key of a widget without an id. */
+    private readonly instanceKey;
+    /** App locale for the `number` / `date` rendering of unlabelled values in value-label columns. */
+    private readonly locale;
+    /**
+     * Bumped on every `config` change: `config` is a plain `@Input`, so the computeds that read it
+     * depend on this signal to pick up a new config on the same widget instance (AB#7655).
+     */
+    private readonly _configVersion;
+    constructor();
     private readonly _isLoading;
     private readonly _data;
     private readonly _error;
-    readonly isLoading: _angular_core.Signal<boolean>;
-    readonly data: _angular_core.Signal<Record<string, unknown>[]>;
-    readonly error: _angular_core.Signal<string | null>;
+    readonly isLoading: Signal<boolean>;
+    readonly data: Signal<Record<string, unknown>[]>;
+    readonly error: Signal<string | null>;
     /** Signal to track query columns from data source (for persistent queries) */
     private readonly _queryColumnsForView;
     /**
@@ -4048,7 +4359,7 @@ declare class TableWidgetComponent implements DashboardWidget<TableWidgetConfig,
      * Converts TableWidgetConfig columns to ListViewComponent TableColumn format.
      * For persistent queries, uses dynamically derived columns from the query response.
      */
-    readonly listViewColumns: _angular_core.Signal<TableColumn$1[]>;
+    readonly listViewColumns: Signal<TableColumn$1[]>;
     /**
      * Checks if the widget has a valid configuration.
      * Supports both runtimeEntity and persistentQuery data sources.
@@ -4059,7 +4370,15 @@ declare class TableWidgetComponent implements DashboardWidget<TableWidgetConfig,
      * For persistent queries, columns are derived from the query response.
      * Returns true once columns are available.
      */
-    readonly columnsReady: _angular_core.Signal<boolean>;
+    readonly columnsReady: Signal<boolean>;
+    /**
+     * Logs one console warning per widget, column and set of problems for ignored `titles` /
+     * `valueLabels` entries (unknown culture keys, malformed titles or value labels, `valueLabels`
+     * together with `statusMapping`, AB#7655). The table still renders. The key carries a hash of the
+     * problem list, so a different problem after a config edit is reported again; widgets without an
+     * id use a per-instance key.
+     */
+    private warnOnce;
     private formatColumnTitle;
     ngOnChanges(changes: SimpleChanges): void;
     refresh(): void;
@@ -4103,6 +4422,10 @@ declare class TableConfigDialogComponent implements OnInit {
     private readonly getCkTypeAvailableQueryColumnsGQL;
     private readonly stateService;
     private readonly windowRef;
+    private readonly getRuntimeQueryColumnsGQL;
+    private readonly queryExecutor;
+    /** Fields the saved query returns now, loaded once per query rtId (AB#7655, kept explicit columns). */
+    private queryFieldsLoad?;
     ckTypeSelectorInput?: CkTypeSelectorInputComponent;
     filterEditor?: FieldFilterEditorComponent;
     querySelector?: QuerySelectorComponent;
@@ -4160,7 +4483,13 @@ declare class TableConfigDialogComponent implements OnInit {
     onFiltersChange(filters: FieldFilterItem[]): void;
     getColumnsSummary(): string;
     getSortingSummary(): string;
-    onSave(): void;
+    /**
+     * The fields a persistent query returns now (`null` when unknown or the lookup failed). Runtime
+     * queries use the metadata-only column resolver; stream-data queries execute with `first: 1`
+     * (no column-introspection endpoint), like the chart dialogs.
+     */
+    private loadQueryFields;
+    onSave(): Promise<void>;
     private formatColumnTitle;
     onCancel(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableConfigDialogComponent, never>;
@@ -5393,6 +5722,7 @@ declare class StatsGridWidgetComponent implements OnInit, OnChanges {
      */
     private resolveStatValue;
     private loadPersistentQueryValue;
+    private scopeOf;
     private buildStreamDataArgs;
     private convertFiltersToDto;
     private getColorClass;
@@ -5985,6 +6315,7 @@ declare class SummaryCardWidgetComponent implements DashboardWidget<SummaryCardW
     private loadData;
     private fetchTileValue;
     private fetchPersistentQueryValue;
+    private scopeOf;
     private buildStreamDataArgs;
     private convertFiltersToDto;
     private fetchEntityAttributes;
@@ -6278,6 +6609,12 @@ interface MeshBoardMessages {
     tableList?: Partial<ListViewMessages>;
     /** Placeholder of a table widget without data source / columns. Default: "Table not configured" */
     tableNotConfigured?: string;
+    /**
+     * Board notice when an entity selector's stream-data scope could not be resolved (AB#7721);
+     * `{label}` is replaced by the selector label. Default:
+     * 'Could not resolve the scope of "{label}" - widgets bound to it show no data.'
+     */
+    scopeResolutionFailed?: string;
 }
 /** Default texts of {@link MeshBoardMessages} (the list texts default inside `mm-list-view`). */
 declare const DEFAULT_MESHBOARD_MESSAGES: Required<Omit<MeshBoardMessages, 'tableList'>>;
@@ -6299,6 +6636,36 @@ declare const MESHBOARD_MESSAGES: InjectionToken<MeshBoardMessagesSource>;
 /** The resolved MeshBoard texts: defaults with the host layer on top (missing / null members keep the default). */
 declare function resolveMeshBoardMessages(messages: MeshBoardMessages | null | undefined): MeshBoardMessages & typeof DEFAULT_MESHBOARD_MESSAGES;
 
+/**
+ * What a host provides on {@link MESHBOARD_LANGUAGE} (AB#7655): the current UI language as a culture
+ * code (`de-AT`, `en-GB`, `de`), fixed or as a signal for apps that switch the language at runtime
+ * (the widgets follow it without reloading data). `null` / `undefined` / `''` = no language.
+ */
+type MeshBoardLanguageSource = string | Signal<string | null | undefined>;
+/**
+ * Optional: the host's current UI language. MeshBoard does not derive it from `LOCALE_ID` (that is
+ * static in many apps); a host that wants per-language texts in board configurations (table column
+ * `titles`, `valueLabels`) hands its language over once, via `provideMeshBoard({ language })`,
+ * `provideMeshBoardLanguage(language)` or this token directly. Not provided = the configured default
+ * texts (e.g. the column `title`).
+ *
+ * ```ts
+ * providers: [provideMeshBoard({ language: languageService.currentLanguage })] // Signal<string>
+ * ```
+ */
+declare const MESHBOARD_LANGUAGE: InjectionToken<MeshBoardLanguageSource>;
+/**
+ * Picks the text for `language` from a per-language map (AB#7655). Lookup order:
+ * 1. the exact culture or language (`de-AT`, `de`; case-insensitive);
+ * 2. a culture (`de-AT`) without an exact key: a key equal to its language part (`de`). A culture
+ *    never picks a sibling culture (`de-DE` does not take `de-AT`);
+ * 3. a bare language (`de`) without an exact key: the first authored key of that language
+ *    (`de-AT` in `{ 'en-GB': …, 'de-AT': …, 'de-DE': … }`), in the map's key order.
+ * Returns `undefined` when there is no language, no map or no match, so the caller applies its own
+ * fallback (e.g. the column `title`).
+ */
+declare function pickLocalizedText(texts: Readonly<Record<string, string>> | null | undefined, language: string | null | undefined): string | undefined;
+
 declare function registerDefaultWidgets(registry: WidgetRegistryService): void;
 /**
  * Provides the widget registry with all built-in widgets registered.
@@ -6332,6 +6699,13 @@ interface MeshBoardOptions {
      * table widget's list texts. Fixed object or signal. Absent = English.
      */
     messages?: MeshBoardMessagesSource;
+    /**
+     * The host's current UI language (AB#7655), provided as `MESHBOARD_LANGUAGE`: a culture code
+     * (`de-AT`) or a signal of it for apps that switch the language at runtime. Board configurations
+     * use it to pick per-language texts (table column `titles`, `valueLabels`). Absent = the default
+     * texts (column `title`); MeshBoard never falls back to `LOCALE_ID`.
+     */
+    language?: MeshBoardLanguageSource;
 }
 /**
  * Injection token for MeshBoard options
@@ -6366,6 +6740,11 @@ declare function provideMeshBoard(options?: MeshBoardOptions): EnvironmentProvid
  * without `provideMeshBoard()` — for apps that register the widgets lazily.
  */
 declare function provideMeshBoardMessages(messages: MeshBoardMessagesSource): EnvironmentProviders;
+/**
+ * Provides the host's UI language (`MESHBOARD_LANGUAGE`, AB#7655) without `provideMeshBoard()` —
+ * for apps that register the widgets lazily. A string or a signal (the widgets follow it).
+ */
+declare function provideMeshBoardLanguage(language: MeshBoardLanguageSource): EnvironmentProviders;
 /**
  * Provider function for registering custom widgets.
  * Use this to add your own widget types to MeshBoard.
@@ -6446,9 +6825,17 @@ declare class EntitySelectorEditorComponent {
     private readonly attributeSelectorService;
     private readonly variableService;
     private readonly getEntitiesByCkTypeGQL;
+    private readonly confirmationService;
+    private readonly cdr;
+    private readonly destroyRef;
     entitySelectors: EntitySelectorConfig[];
     /** Existing variable names from other sources (static variables, other selectors) for duplicate detection */
     existingVariableNames: string[];
+    /**
+     * The board's static variables (AB#7724): offered in the picker filter and
+     * substituted when the editor lists default entities and checks the default.
+     */
+    variables: MeshBoardVariable[];
     entitySelectorsChange: EventEmitter<EntitySelectorConfig[]>;
     /** Emits true when entering edit mode, false when leaving — allows parent to hide its own buttons */
     editingStateChange: EventEmitter<boolean>;
@@ -6464,12 +6851,19 @@ declare class EntitySelectorEditorComponent {
     protected editMappings: EntitySelectorAttributeMapping[];
     protected editShowInToolbar: boolean;
     protected editDefaultRtId: string;
-    protected editChildScopeTargetCkTypeId: string;
-    protected editChildScopeTargetCkTypeItem: CkTypeSelectorItem | null;
-    protected editChildScopeRoleId: string;
-    protected editChildScopeDirection: 'in' | 'out';
+    protected editScopeHops: EntitySelectorScopeHop[];
+    protected editFollowsSelectorId: string;
+    /** Why choosing the leader changed the form (CK type fixed, mappings/default cleared). */
+    protected followNotice: string;
+    protected editFilters: FieldFilterItem[];
+    /** Filter rows a follower carries from hand-editing; ignored and dropped on save. */
+    protected followerFilterCount: number;
+    /** Result of the server check whether the default entity matches the filter. */
+    protected defaultFilterCheck: DefaultFilterCheck;
+    private readonly defaultCheckRequests;
     protected defaultEntityDataSource: RuntimeEntitySelectDataSource | null;
     protected defaultEntityDialogDataSource: RuntimeEntityDialogDataSource | null;
+    constructor();
     /**
      * Starts adding a new entity selector.
      */
@@ -6481,7 +6875,29 @@ declare class EntitySelectorEditorComponent {
     /**
      * Removes an entity selector at the given index.
      */
-    removeSelector(index: number): void;
+    removeSelector(index: number): Promise<void>;
+    /** Selectors the edited selector may follow (non-followers, never itself). */
+    get leaderOptions(): EntitySelectorConfig[];
+    /** Selectors that follow the edited selector (it then cannot follow one itself). */
+    get followedBy(): EntitySelectorConfig[];
+    /** True when the stored leader is not among the selectable leaders (deleted or a follower). */
+    get isLeaderUnavailable(): boolean;
+    /** "A, B and C" of the selectors following the edited one. */
+    get followedByLabels(): string;
+    /** Validation message of the "Follows" choice, or '' when it is valid. */
+    get followError(): string;
+    /** True while the edited selector follows another one. */
+    get isFollower(): boolean;
+    /**
+     * Handles a change of the "Follows" choice. Choosing a leader fixes the CK type
+     * to the leader's (clearing default entity and mappings with a notice when the
+     * type changes) and hides the toolbar option; back to none makes the CK type
+     * editable again with "Show in Toolbar" unchecked.
+     */
+    onFollowsChanged(leaderId: string): void;
+    /** True when the selector names a leader that does not exist or is itself a follower. */
+    isOrphanFollower(selector: EntitySelectorConfig): boolean;
+    private applyLeaderCkType;
     /**
      * Handles CK type selection in the editor form.
      */
@@ -6494,14 +6910,10 @@ declare class EntitySelectorEditorComponent {
      * Opens the attribute selector dialog to pick attributes for variable mappings.
      */
     selectAttributes(): Promise<void>;
-    /**
-     * Handles child-scope target CK type selection.
-     */
-    onChildScopeCkTypeSelected(ckType: CkTypeSelectorItem): void;
-    /**
-     * Handles child-scope target CK type cleared.
-     */
-    onChildScopeCkTypeCleared(): void;
+    /** Takes the hop list of the child-scope editor (AB#7723). */
+    onScopeHopsChanged(hops: EntitySelectorScopeHop[]): void;
+    /** Validation message of the hop list, or '' when it can be saved. */
+    get scopeHopsError(): string;
     /**
      * Handles default entity selection from the entity picker.
      */
@@ -6510,6 +6922,20 @@ declare class EntitySelectorEditorComponent {
      * Handles default entity cleared.
      */
     onDefaultEntityCleared(): void;
+    /** Takes the rows of the picker filter editor (AB#7724). */
+    onFiltersChange(filters: FieldFilterItem[]): void;
+    /**
+     * Variables offered in filter values: the board's static variables and the
+     * variables other selectors map. The edited selector's own mappings are
+     * left out — they are filled from its own pick.
+     */
+    get filterVariables(): FilterVariable[];
+    /** "2 filters" chip of a selector in the list, or '' without filter. */
+    getFilterSummary(selector: EntitySelectorConfig): string;
+    /** "$a, $b" of the variables the default-entity check cannot substitute. */
+    get uncheckedVariablesText(): string;
+    /** Label of the leader the edited follower takes its pick from. */
+    get leaderLabel(): string;
     /**
      * Saves the current entity selector being edited.
      */
@@ -6549,9 +6975,143 @@ declare class EntitySelectorEditorComponent {
     getVariableNameError(mapping: EntitySelectorAttributeMapping): string;
     private generateSelectorId;
     private updateDefaultEntityDataSources;
+    private toFilterConfigs;
+    /**
+     * The filter rows that apply in the editor, with the board's static
+     * variables substituted. Rows whose value still names a variable without a
+     * value (e.g. one a selector pick fills at view time) are left out and
+     * reported in `unresolved`; the editor cannot know their value.
+     */
+    private resolvedEditorFilters;
+    /** Queues the (debounced) check whether the default entity matches the filter. */
+    private requestDefaultCheck;
+    /** Asks the server whether the entity is among the filtered ones (rtId + filter, first 1). */
+    private checkDefaultEntity;
     private emitChange;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntitySelectorEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntitySelectorEditorComponent, "mm-entity-selector-editor", never, { "entitySelectors": { "alias": "entitySelectors"; "required": false; }; "existingVariableNames": { "alias": "existingVariableNames"; "required": false; }; }, { "entitySelectorsChange": "entitySelectorsChange"; "editingStateChange": "editingStateChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntitySelectorEditorComponent, "mm-entity-selector-editor", never, { "entitySelectors": { "alias": "entitySelectors"; "required": false; }; "existingVariableNames": { "alias": "existingVariableNames"; "required": false; }; "variables": { "alias": "variables"; "required": false; }; }, { "entitySelectorsChange": "entitySelectorsChange"; "editingStateChange": "editingStateChange"; }, never, never, true, never>;
+}
+/**
+ * Outcome of the default-entity filter check (AB#7724). Never blocks saving:
+ * `mismatch` warns, `error` says the check failed, `unchecked` names the
+ * variables the editor cannot substitute.
+ */
+type DefaultFilterCheck = {
+    state: 'none';
+} | {
+    state: 'match';
+} | {
+    state: 'mismatch';
+} | {
+    state: 'error';
+} | {
+    state: 'unchecked';
+    variables: string[];
+};
+
+/** One association of a CK type as the "Association" dropdown offers it. */
+interface ScopeAssociationOption {
+    /** `<direction>|<roleId>|<baseTargetCkTypeId>`, or {@link OTHER_ASSOCIATION}. */
+    key: string;
+    roleId: string;
+    direction: 'in' | 'out';
+    /** Target type of the association in the CK metadata (base type for the target-type picker). */
+    baseTargetCkTypeId: string;
+    label: string;
+}
+/** Editor row of one hop. */
+interface HopRow {
+    roleId: string;
+    direction: 'in' | 'out';
+    targetCkTypeId: string;
+    targetItem: CkTypeSelectorItem | null;
+    /** Key of the chosen association, or {@link OTHER_ASSOCIATION} for free text. */
+    associationKey: string;
+}
+/**
+ * Hop list of an entity selector's child scope (AB#7723; wireframe agreed by
+ * Freya, AB#7723 comment 6625315). Each hop picks an association of its source
+ * type from the CK metadata (role + direction + base target in one entry, or
+ * "Other role…" for free text) and a target type restricted to types derived
+ * from the association's target. The source type of hop 1 is the selector's
+ * CK type, of every later hop the previous hop's target type. Hops can be
+ * added (at most {@link MAX_SCOPE_HOPS}), removed and moved up/down.
+ *
+ * Two-way bindable; emits the hops as configured (validation is the host's,
+ * see `scopeHopsValidationError`):
+ * ```html
+ * <mm-entity-selector-scope-path-editor
+ *   [sourceCkTypeId]="ckTypeId"
+ *   [(hops)]="hops">
+ * </mm-entity-selector-scope-path-editor>
+ * ```
+ */
+declare class EntitySelectorScopePathEditorComponent {
+    private readonly rolesGQL;
+    private readonly cdr;
+    hopsChange: EventEmitter<EntitySelectorScopeHop[]>;
+    private hopCards?;
+    protected rows: HopRow[];
+    protected readonly plusIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly arrowUpIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly arrowDownIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly trashIcon: _progress_kendo_svg_icons.SVGIcon;
+    private _sourceCkTypeId;
+    private lastEmitted;
+    private readonly associations;
+    /** CK type of the picked entity — the source type of hop 1. */
+    set sourceCkTypeId(value: string | null | undefined);
+    get sourceCkTypeId(): string;
+    /** The configured hops (one-hop form = one hop). */
+    set hops(value: EntitySelectorScopeHop[] | null | undefined);
+    /** Maximum hop count (getter: relative imports must not initialise fields, see CLAUDE.md). */
+    get maxHops(): number;
+    get canAddHop(): boolean;
+    /** "Test/Site → Test/System → Test/Device". */
+    get pathLabel(): string;
+    /** True when the association metadata of any shown source type could not be loaded. */
+    get metadataFailed(): boolean;
+    /** Source type of hop `index`. */
+    sourceTypeOf(index: number): string;
+    /** Dropdown entries of hop `index`: the source type's associations plus "Other role…". */
+    associationOptions(index: number): ScopeAssociationOption[];
+    /** True when hop `index` offers the association dropdown (metadata loaded with ≥1 association). */
+    hasAssociationList(index: number): boolean;
+    /** True when hop `index` shows the free-text role and direction fields. */
+    isFreeText(index: number): boolean;
+    /** Base type the target-type picker of hop `index` is restricted to (undefined = any type). */
+    baseTargetOf(index: number): string | undefined;
+    /**
+     * Warning of hop `index` when its role is not an association of its (new)
+     * source type — after a reorder, a removal or a changed earlier target. The
+     * values are kept; it does not block saving.
+     */
+    associationWarning(index: number): string;
+    /** Validation message of hop `index`: an incomplete hop blocks saving (see `scopeHopsValidationError`). */
+    hopError(index: number): string;
+    isRoleInvalid(index: number): boolean;
+    isTargetInvalid(index: number): boolean;
+    addHop(): void;
+    removeHop(index: number): void;
+    moveHop(index: number, delta: -1 | 1): void;
+    onAssociationChanged(index: number, key: string): void;
+    onRoleChanged(index: number, roleId: string): void;
+    onDirectionChanged(index: number, direction: 'in' | 'out'): void;
+    onTargetSelected(index: number, ckType: CkTypeSelectorItem): void;
+    onTargetCleared(index: number): void;
+    private emit;
+    private loadOf;
+    /**
+     * Matches every hop's role/direction to an entry of its source type's
+     * associations (loading missing metadata); a hop whose association is not
+     * listed switches to "Other role…" with its values kept.
+     */
+    private syncAssociationKeys;
+    private loadAssociations;
+    /** Keeps the keyboard focus on a moved hop (wireframe change 4). */
+    private focusHop;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntitySelectorScopePathEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntitySelectorScopePathEditorComponent, "mm-entity-selector-scope-path-editor", never, { "sourceCkTypeId": { "alias": "sourceCkTypeId"; "required": false; }; "hops": { "alias": "hops"; "required": false; }; }, { "hopsChange": "hopsChange"; }, never, never, true, never>;
 }
 
 /**
@@ -6569,18 +7129,34 @@ interface EntitySelectorClearEvent {
 }
 /**
  * Toolbar component that renders entity select inputs for each configured entity selector.
- * Creates data sources per CK type and emits selection/clear events.
+ * Creates data sources per CK type and picker filter (AB#7724) and emits selection/clear events.
  */
 declare class EntitySelectorToolbarComponent implements OnChanges {
     private readonly getEntitiesByCkTypeGQL;
+    private readonly variableService;
     entitySelectors: EntitySelectorConfig[];
+    /**
+     * Board variables substituted into the selectors' picker filters (AB#7724),
+     * the same substitution widget filters get.
+     */
+    variables: MeshBoardVariable[];
     entitySelected: EventEmitter<EntitySelectorEvent>;
     entityCleared: EventEmitter<EntitySelectorClearEvent>;
     private dataSourceCache;
     private dialogDataSourceCache;
     protected selectorDataSources: Map<string, RuntimeEntitySelectDataSource>;
     protected selectorDialogDataSources: Map<string, RuntimeEntityDialogDataSource>;
+    protected selectorMessages: Map<string, Partial<EntitySelectInputMessages>>;
     ngOnChanges(changes: SimpleChanges): void;
+    /** Texts of the selector's picker: a filtered picker explains its empty list (AB#7724). */
+    getMessages(selector: EntitySelectorConfig): Partial<EntitySelectInputMessages>;
+    /** Title of the selector's search dialog; marks a filtered picker (AB#7724). */
+    getDialogTitle(selector: EntitySelectorConfig): string;
+    /**
+     * True when the selector renders a picker. Hidden selectors and followers
+     * (AB#7722) never do; a follower's pick is derived from its leader.
+     */
+    showsInToolbar(selector: EntitySelectorConfig): boolean;
     /**
      * Returns the data source for a selector.
      */
@@ -6598,11 +7174,17 @@ declare class EntitySelectorToolbarComponent implements OnChanges {
      */
     onEntityCleared(selectorId: string): void;
     /**
-     * Creates or retrieves cached data sources for each selector.
+     * Creates or retrieves cached data sources for each selector. Selectors of
+     * the same CK type and the same resolved filter share their data sources; a
+     * selector without filter uses the plain query, exactly as before AB#7724.
+     * Entries no selector uses any more (e.g. after a filter variable changed)
+     * are dropped, so the caches never outgrow the current selectors.
      */
     private updateDataSources;
+    /** Number of cached data source pairs (for tests). */
+    get cachedDataSourceCount(): number;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntitySelectorToolbarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntitySelectorToolbarComponent, "mm-entity-selector-toolbar", never, { "entitySelectors": { "alias": "entitySelectors"; "required": false; }; }, { "entitySelected": "entitySelected"; "entityCleared": "entityCleared"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntitySelectorToolbarComponent, "mm-entity-selector-toolbar", never, { "entitySelectors": { "alias": "entitySelectors"; "required": false; }; "variables": { "alias": "variables"; "required": false; }; }, { "entitySelected": "entitySelected"; "entityCleared": "entityCleared"; }, never, never, true, never>;
 }
 
 /**
@@ -6626,6 +7208,28 @@ interface WidgetPlacement {
     rowSpan: number;
 }
 
+/**
+ * The period a host page sets on an embedded MeshBoard (`mm-meshboard-view [timeRange]`, AB#7582):
+ * two exact instants, half-open `[from, to)`. A string must be an RFC 3339 date-time with an
+ * explicit offset - see {@link parseHostTimeRange}.
+ */
+interface MeshBoardHostTimeRange {
+    from: Date | string;
+    to: Date | string;
+}
+/**
+ * Who controls the board's period: `board` (default) shows the board's own time-range picker;
+ * `host` hides the picker and its reset button because the host page owns the period.
+ */
+type MeshBoardTimeFilterControl = 'board' | 'host';
+/**
+ * Parses the host's `timeRange` input. `undefined`/`null` = the host sets no period.
+ * Never snaps or converts: the instants are taken as given. `Date` objects are accepted as they
+ * are; strings must be RFC 3339 with an offset, e.g. `2026-03-28T05:00:00Z` or
+ * `2026-03-28T06:00:00+01:00` (see {@link RFC3339}).
+ */
+declare function parseHostTimeRange(value: MeshBoardHostTimeRange | null | undefined): HostTimeRangeState | undefined;
+
 interface WidgetPositionUpdate {
     id: string;
     title: string;
@@ -6734,6 +7338,41 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
     readonly chrome: _angular_core.InputSignal<MeshBoardChrome | undefined>;
     private readonly routeChrome;
     protected readonly effectiveChrome: _angular_core.Signal<MeshBoardChrome>;
+    /**
+     * The period set by the host page (AB#7582): two exact instants, half-open `[from, to)`, as
+     * `Date` objects or ISO 8601 strings with a zone designator. While set (and the board's time
+     * filter is enabled) the view publishes exactly these instants as `$timeRangeFrom` /
+     * `$timeRangeTo` and as the stream-data window - no day snapping, no zone conversion - and
+     * ignores the `tf_*` query parameters and the stored/default selection. It writes no `tf_*`
+     * parameters and causes no unsaved changes. A change reloads the widgets once; `undefined`
+     * returns the board to its own selection. Day rules (e.g. a 06:00 gas day) belong to the host.
+     * An invalid range (unparseable, or `from >= to`) sends no stream-data query and logs one
+     * console error. A board with the time filter disabled ignores the input.
+     */
+    readonly timeRange: _angular_core.InputSignal<MeshBoardHostTimeRange | undefined>;
+    /**
+     * Who controls the period: `board` (default, unchanged behaviour) shows the board's time-range
+     * picker; `host` hides the picker and its reset button - entity selectors and actions stay.
+     * While `timeRange` is set the picker is hidden and its events are ignored either way.
+     */
+    readonly timeFilterControl: _angular_core.InputSignal<MeshBoardTimeFilterControl>;
+    /** The parsed `timeRange` input; `undefined` = the host sets no period. */
+    protected readonly parsedHostTimeRange: _angular_core.Signal<HostTimeRangeState | undefined>;
+    /** True while the host owns the period (a valid or an invalid `timeRange` is set). */
+    protected readonly isHostTimeRangeActive: _angular_core.Signal<boolean>;
+    /** Whether the board's own time-range picker (and its reset button) is rendered. */
+    protected readonly showTimeRangePicker: _angular_core.Signal<boolean>;
+    /** The host range last applied to the state service (to reload only on a real change). */
+    private appliedHostTimeRange;
+    /** The invalid host range already reported, so a board switch does not log it again. */
+    private reportedInvalidHostTimeRange;
+    /**
+     * Set once the host has owned the period: the `tf_*` parameters of the URL this view was opened
+     * with are stale from then on and are not applied again when `timeRange` goes back to undefined.
+     */
+    private hostHasOwnedPeriod;
+    /** Set in ngOnDestroy; the async initial load stops touching shared state after it (AB#7582). */
+    private destroyed;
     protected readonly meshBoardPageLink: _angular_core.Signal<string>;
     protected readonly hasWidgets: _angular_core.Signal<boolean>;
     /** Widgets shown: outside edit mode those that reported "nothing for this viewer" are collapsed (AB#5558). */
@@ -6756,6 +7395,8 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
     private readonly _urlTimeSelection;
     protected readonly initialTimeSelection: _angular_core.Signal<TimeRangeSelection$1 | undefined>;
     protected readonly entitySelectorsConfig: _angular_core.Signal<EntitySelectorConfig[]>;
+    /** Board variables substituted into the selectors' picker filters (AB#7724). */
+    protected readonly boardVariables: _angular_core.Signal<_meshmakers_octo_meshboard.MeshBoardVariable[]>;
     protected readonly hasEntitySelectors: _angular_core.Signal<boolean>;
     protected readonly unselectedToolbarSelectors: _angular_core.Signal<EntitySelectorConfig[]>;
     /**
@@ -6778,7 +7419,12 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
      * fail with a NavigationError (AB#4457).
      */
     private updateUrlWithRtId;
-    /** The active time-filter selection to mirror into the URL, or null when the filter is off. */
+    /**
+     * The active time-filter selection to mirror into the URL, or null when the filter is off or
+     * the host owns the period or controls the filter (AB#7582: the view then writes no tf_*
+     * parameters; with `timeFilterControl='host'` and no `timeRange` the board selection still
+     * applies, but the URL is the host's).
+     */
     private activeTimeFilterSelection;
     ngOnInit(): Promise<void>;
     /**
@@ -6802,8 +7448,22 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
     /**
      * Initializes time filter variables based on URL query params or stored selection.
      * URL params take precedence over stored selection to support page reload.
+     * A period set by the host (`timeRange`, AB#7582) takes precedence over both.
      */
     private initializeTimeFilterVariables;
+    /**
+     * Hands the host period to the state service and publishes `$timeRangeFrom` / `$timeRangeTo`
+     * as exactly its instants (AB#7582). Returns true while the host owns the period, so the
+     * caller skips the board's own selection. With the time filter disabled the period is only
+     * stored (the state service ignores it then) and nothing is logged.
+     */
+    private applyHostTimeRange;
+    /**
+     * Applies a change of the `timeRange` input after the initial load (AB#7582): the host period,
+     * or the board's own selection again when the input went back to `undefined`. Reloads the
+     * widgets once; an equal period (same instants) changes nothing.
+     */
+    private onHostTimeRangeChanged;
     /**
      * Recomputes the active time-filter range from the current selection on the
      * board's (possibly just-changed) timezone mode and republishes the
@@ -6869,8 +7529,35 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
      * Programmatically clears an entity selector value from outside the component.
      */
     clearEntitySelector(selectorId: string): void;
+    /**
+     * Clears one selector's pick, variables and scope state. Without a pick bound
+     * widgets fall back to the persisted scope (AB#7721).
+     */
+    private clearSelectorPick;
+    /**
+     * The leader `leaderId` has no pick any more: each of its followers resolves
+     * its own `defaultRtId`, or — without one — has no pick and no scope
+     * (AB#7722). Followers with a default are marked pending synchronously.
+     * Returns a promise for the default resolutions, or `null` when there are none.
+     */
+    private resetFollowersOf;
     /** Resolution errors for runtime entity variables */
     readonly variableResolutionErrors: _angular_core.Signal<_meshmakers_octo_meshboard.VariableResolutionError[]>;
+    private readonly messages;
+    /**
+     * One notice per entity selector whose stream-data scope could not be
+     * resolved (AB#7721), so "nothing in scope" (empty widgets, no notice) and
+     * "lookup failed" (empty widgets plus this notice) are distinguishable.
+     */
+    protected readonly scopeResolutionErrors: _angular_core.Signal<{
+        selectorId: string;
+        message: string;
+    }[]>;
+    /**
+     * Per-selector sequence number of the latest scope resolution, so a slower
+     * resolution of an earlier pick never overwrites the scope of a newer pick.
+     */
+    private readonly scopeRequestSeq;
     /**
      * Handles time range change from the time range picker.
      * No-op: refresh is triggered by onTimeSelectionChange to ensure variables are updated first.
@@ -6992,19 +7679,63 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
      */
     private initializeEntitySelectors;
     /**
-     * Resolves variables for an entity selector by fetching entity attributes.
+     * The initial pick of each entity selector. Priority: route data > URL
+     * params > defaultRtId. Selectors without a pick are left out.
+     *
+     * Followers (AB#7722) never read route data or the URL: a follower takes its
+     * leader's initial pick (`viaLeader: true`, resolved together with the
+     * leader) and falls back to its own `defaultRtId` only when the leader has
+     * none. An unknown or chained leader counts as "leader has no pick"; with
+     * `warn` set this logs a console warning.
+     */
+    private initialEntitySelectorPicks;
+    /**
+     * Marks the scope of every selector that has an initial pick as pending
+     * (AB#7721). Called synchronously right after a board is loaded, before
+     * change detection renders its widgets, so a bound stream-data widget starts
+     * in its loading state instead of querying the persisted (unscoped) scope.
+     * Selectors without a pick stay without scope state (persisted scope).
+     */
+    private primeEntitySelectorScopes;
+    /**
+     * Resolves variables for an entity selector by fetching entity attributes,
+     * then its stream-data scope.
+     *
+     * A leader's pick is also the pick of all its followers (AB#7722): they are
+     * marked pending together with the leader, the picked entity is fetched
+     * once, and each follower gets its own variables (its attribute mappings,
+     * `<id>_rtId`, `<id>_rtCkTypeId`), its own scope (its `childScope`) and the
+     * leader's selection. Returns the picked entity's display name.
      */
     private resolveEntitySelectorVariables;
+    /**
+     * The variables one selector derives from the picked entity: its attribute
+     * mappings plus the auto-exposed `<id>_rtId` and `<id>_rtCkTypeId`.
+     */
+    private selectorVariables;
     /**
      * Resolves the set of source rtIds that a stream-data widget bound to this
      * selector should be scoped to, and caches them on the state service.
      *
-     * When the selector defines a {@link EntitySelectorChildScope}, the picked
-     * entity's children of `targetCkTypeId` reached via `roleId`/`direction`
-     * become the scope (e.g. MeteringPoint → its EnergyMeasurement rtIds). With
-     * no childScope, the picked entity's own rtId is the scope (direct keying).
+     * - No {@link EntitySelectorChildScope}: the picked entity's own rtId is the
+     *   scope (direct keying).
+     * - One-hop form (top-level fields): the picked entity's targets of
+     *   `targetCkTypeId` reached via `roleId`/`direction` (e.g. MeteringPoint →
+     *   its EnergyMeasurement rtIds) — exactly as before AB#7723.
+     * - `path` (AB#7723): hop by hop, each hop one batched request over all
+     *   entities the previous hop reached; the scope is the distinct rtIds of the
+     *   last hop. An empty hop ends the resolution with an empty scope; a failed
+     *   hop, or an invalid path (more than 5 hops, a hop without role or target
+     *   type), is a failed scope (AB#7721).
      */
     private resolveEntitySelectorScopeRtIds;
+    /**
+     * Starts the scope resolution of a new pick: marks the scope pending and
+     * returns the sequence number that identifies this resolution (AB#7721).
+     */
+    private beginScopeResolution;
+    /** Marks the scope failed — unless a newer pick has started resolving meanwhile. */
+    private failScopeResolution;
     /**
      * Writes entity selector selections to URL query parameters.
      * Format: es_<selectorId>=<rtId>
@@ -7026,7 +7757,7 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
      */
     saveChanges(): Promise<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardViewComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MeshBoardViewComponent, "mm-meshboard-view", never, { "headerMode": { "alias": "headerMode"; "required": false; "isSignal": true; }; "chrome": { "alias": "chrome"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.UnsavedChangesDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MeshBoardViewComponent, "mm-meshboard-view", never, { "headerMode": { "alias": "headerMode"; "required": false; "isSignal": true; }; "chrome": { "alias": "chrome"; "required": false; "isSignal": true; }; "timeRange": { "alias": "timeRange"; "required": false; "isSignal": true; }; "timeFilterControl": { "alias": "timeFilterControl"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.UnsavedChangesDirective; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -8888,5 +9619,5 @@ declare function pipelineExecutionInputs(children: (unknown | null)[] | null | u
  */
 declare function countPipelineExecutions(pipelines: PipelineExecutionInput[], now?: number): PipelineExecutionCounts;
 
-export { ADAPTER_OFFLINE_GRACE_MS, ATTENTION_SEVERITY_ORDER, AdaptersAttentionProvider, AddWidgetDialogComponent, AiInsightsConfigDialogComponent, AiInsightsService, AiInsightsWidgetComponent, AlertBannerConfigDialogComponent, AlertBannerWidgetComponent, AlertListConfigDialogComponent, AlertListWidgetComponent, AssociationsConfigDialogComponent, AttentionListConfigDialogComponent, AttentionListWidgetComponent, AutoRefreshTimerService, BUILT_IN_ATTENTION_PROVIDERS, BarChartConfigDialogComponent, BarChartWidgetComponent, BlueprintUpdatesAttentionProvider, COCKPIT_ADAPTER_LIMIT, COCKPIT_ATTENTION_PROVIDERS, COCKPIT_BLUEPRINT_CATALOG_LIMIT, COCKPIT_CHILD_TENANT_IDS, COCKPIT_DATA_FLOW_LIMIT, COCKPIT_EXPLAIN_HANDLER, COCKPIT_FAILED_EXECUTIONS_OPTIONS, COCKPIT_KPI_GATES, COCKPIT_KPI_SLOW_LOADING_MS, COCKPIT_LINK_RESOLVER, COCKPIT_RECENT_ITEMS, COCKPIT_ROLES, COCKPIT_SERVICE_NAMES, COCKPIT_VERSION_SOURCE, COCKPIT_VIEWER_ACCESS, COCKPIT_WIDGET_MESSAGES, COCKPIT_WIDGET_TYPES, CkModelsResolveFailedAttentionProvider, CockpitAdapterStatesService, CockpitAttentionService, CockpitBlueprintStatusService, CockpitChildTenantsService, CockpitCkModelStatesService, CockpitContextService, CockpitDataFlowExecutionsService, CockpitKpiConfigDialogComponent, CockpitKpiService, CockpitKpiWidgetComponent, CockpitServiceHealthService, DAY_MS, DEFAULT_ATTENTION_MAX_ITEMS, DEFAULT_COCKPIT_WIDGET_MESSAGES, DEFAULT_FAILED_EXECUTIONS_OPTIONS, DEFAULT_MESHBOARD_MESSAGES, DEFAULT_RECENT_ITEMS_MAX, DEFAULT_TIME_ZONE_MODE, DashboardDataService, DashboardGridService, EditModeStateService, EditWidgetDialogComponent, EntityAssociationsWidgetComponent, EntityCardConfigDialogComponent, EntityCardWidgetComponent, EntityDetailDialogComponent, EntitySelectorEditorComponent, EntitySelectorToolbarComponent, FALLBACK_SERIES_COLORS, FailedExecutionsAttentionProvider, FeaturesNotInstalledAttentionProvider, GaugeConfigDialogComponent, GaugeWidgetComponent, HISTOGRAM_HOURS, HOUR_MS, HeatmapConfigDialogComponent, HeatmapWidgetComponent, KPI_ERROR_TEXT, KpiConfigDialogComponent, KpiWidgetComponent, LazyMarkdownComponent, LineChartConfigDialogComponent, LineChartWidgetComponent, MAX_RECENT_ITEMS, MESHBOARD_CHROME_ROUTE_DATA, MESHBOARD_DESCRIPTION_MARKER, MESHBOARD_EDIT_QUERY_PARAM, MESHBOARD_HEADER_MODE_ROUTE_DATA, MESHBOARD_LABEL_RESOLVER, MESHBOARD_MESSAGES, MESHBOARD_OPTIONS, MESHBOARD_TENANT_ID_PROVIDER, MarkdownConfigDialogComponent, MarkdownWidgetComponent, MeshBoardDataService, MeshBoardGridService, MeshBoardManagerDialogComponent, MeshBoardPersistenceService, MeshBoardSettingsDialogComponent, MeshBoardSettingsResult, MeshBoardStateService, MeshBoardViewComponent, NOT_AVAILABLE_TEXT, PieChartConfigDialogComponent, PieChartWidgetComponent, QueryExecutorService, QuerySelectorComponent, RecentItemsConfigDialogComponent, RecentItemsWidgetComponent, RuntimeEntitySelectorComponent, SERVICE_MANAGED_BLUEPRINT_PREFIX, STATE_STATUS_BY_KEY, ServiceHealthConfigDialogComponent, ServiceHealthWidgetComponent, ServicesHealthAttentionProvider, StatsGridConfigDialogComponent, StatsGridWidgetComponent, StatusIndicatorConfigDialogComponent, StatusIndicatorWidgetComponent, StatusListConfigDialogComponent, StatusListWidgetComponent, SummaryCardConfigDialogComponent, SummaryCardWidgetComponent, TableConfigDialogComponent, TableWidgetComponent, TableWidgetDataSourceDirective, UnregisteredPoolsAttentionProvider, WidgetFactoryService, WidgetGroupComponent, WidgetGroupConfigDialogComponent, WidgetNotConfiguredComponent, WidgetRegistryService, adapterKpi, adaptersInError, adaptersOffline, blueprintUpdatesKpi, buildHourlyHistogram, categoryStatus, chartSeriesColors, ckModelKpi, classifyQuery, compareBlueprintVersions, compareMeshBoardNavigation, countFlowExecutions, countLabel, countPipelineExecutions, enabledButNotInstalled, executionKpi, failedExecutionsSeverity, formatCockpitMessage, formatCount, humanizeCategory, isAdapterAtRest, isAdapterExpectedToRun, isAdapterOnline, isCockpitWidgetType, isMeshBoardChrome, isMeshBoardHeaderMode, isServiceConfigured, joinEncodedDescription, kpiKindOf, latestStatisticsUpdate, legacyCockpitLinkTarget, loadNgxMarkdown, nameList, newMeshBoardConfig, normalizeNavigation, observeThemeChanges, pipelineExecutionInputs, plural, provideCockpitWidgetHost, provideCockpitWidgets, provideDefaultWidgets, provideMeshBoard, provideMeshBoardMessages, provideProcessWidget, provideWidgetRegistrations, queryFamily, readMeshBoardNavigation, recentRelativeTime, registerCockpitWidgets, registerDefaultWidgets, registerProcessWidget, resolveChartColor, resolveCockpitWidgetMessages, resolveMeshBoardChrome, resolveMeshBoardHeaderMode, resolveMeshBoardLabel, resolveMeshBoardMessages, selectProviders, serviceStateText, servicesHealthKpi, sortAttentionFindings, sparklineGeometry, splitBlueprintId, splitEncodedDescription, statusColor, summarizeAdapterOnline, tenantCountKpi, toBlueprintStatus, toServiceHealthStatus, truncationNote, versionKpi, withMeshBoardNavigation };
-export type { AdapterOnlineFields, AdapterOnlineSummary, AdapterStatusWidgetConfig, AggregationDataSource, AggregationQuery, AggregationType, AiInsightsConfigResult, AiInsightsWidgetConfig, AlertBannerConfigResult, AlertBannerWidgetConfig, AlertListConfigResult, AlertListWidgetConfig, AnyWidgetConfig, AssociationsConfigResult, AttentionContext, AttentionFinding, AttentionLink, AttentionListConfigResult, AttentionListWidgetConfig, AttentionProvider, AttentionProviderInfo, AttentionSeverity, AttentionState, BarChartColorThreshold, BarChartConfigResult, BarChartSeries, BarChartType, BarChartWidgetConfig, BaseWidgetConfig, BlueprintUpdatesWidgetConfig, CategoryStatus, CategoryValueItem, ChartReferenceLine, CkModelStateWidgetConfig, CkQueryResult, CkQueryTarget, CkTypeAttributeInfo, CockpitAdapterState, CockpitAdapterStates, CockpitBlueprintStatus, CockpitBlueprintUpdate, CockpitChildTenants, CockpitCkModelCounts, CockpitDataFlowExecutions, CockpitDataFlowRow, CockpitExecutionCounts, CockpitExplainHandler, CockpitExplainTarget, CockpitKpi, CockpitKpiConfigResult, CockpitKpiKind, CockpitKpiResult, CockpitKpiStatus, CockpitKpiWidgetConfig, CockpitKpiWidgetOptions, CockpitLinkQueryParams, CockpitLinkResolver, CockpitLinkTarget, CockpitRecentItem, CockpitRecentItemKind, CockpitRecentItemsSource, CockpitResolvedLink, CockpitRouteLinkTarget, CockpitServiceHealth, CockpitServiceHealthStatus, CockpitServiceKey, CockpitVersionEntry, CockpitVersionSource, CockpitViewerAccess, CockpitWidgetHost, CockpitWidgetMessages, CockpitWidgetMessagesSource, CockpitWidgetType, ConfigDialogResult, ConfigResultApplier, ConstructionKitQueryDataSource, DashboardConfig, DashboardWidget, DataSource, DataSourceType, DiagramPropertyMapping, EncodedDescription, EntityAssociation, EntityAttribute, EntityCardConfigResult, EntityCardWidgetConfig, EntityListWidget, EntitySelectorAttributeMapping, EntitySelectorChildScope, EntitySelectorClearEvent, EntitySelectorConfig, EntitySelectorEvent, EntityWidget, EntityWithAssociationsWidgetConfig, FailedExecutionsAttentionOptions, GaugeConfigResult, GaugeRange, GaugeType, GaugeWidgetConfig, GridCell, GridPosition, GroupChildWidgetType, GroupedDataItem, HeatmapAggregation, HeatmapColorMode, HeatmapColorScheme, HeatmapConfigResult, HeatmapWidgetConfig, HourlyExecutionBucket, HourlyHistogramOptions, KpiConfigResult, KpiDataSourceType, KpiQueryMode, KpiValueMode, KpiWidgetConfig, LatestExecutionInput, LineChartConfigResult, LineChartType, LineChartWidgetConfig, MarkdownConfigResult, MarkdownTextAlign, MarkdownWidgetConfig, MeshBoardChrome, MeshBoardConfig, MeshBoardHeaderMode, MeshBoardLabelKind, MeshBoardLabelRequest, MeshBoardLabelResolver, MeshBoardMessages, MeshBoardMessagesSource, MeshBoardNavigationConfig, MeshBoardOptions, MeshBoardTimeFilterConfig, MeshBoardTimeZoneMode, MeshBoardVariable, MeshBoardVariableSource, MeshBoardVariableType, ParentAssociationMode, PersistedDashboard, PersistedMeshBoard, PersistedWidget, PersistedWidgetData, PersistentQueryCellMode, PersistentQueryCellSource, PersistentQueryDataSource, PersistentQueryItem, PieChartConfigResult, PieChartLabelPosition, PieChartType, PieChartWidgetConfig, PipelineExecutionCounts, PipelineExecutionInput, PipelineExecutionsWidgetConfig, PipelineStatisticsInput, ProcessWidgetConfig, Quarter, QueryCell, QueryClassification, QueryColumn, QueryColumnInfo, QueryColumnItem, QueryExecutionOptions, QueryExecutionResult, QueryFamily, QueryKind, QueryResultRow, RawHourBucket, RecentItemsConfigResult, RecentItemsWidgetConfig, RelativeTimeUnit, RepeaterDataItem, RepeaterQueryDataSource, RuntimeEntityData, RuntimeEntityDataSource, RuntimeEntitySelectorValue, SeriesAggregationFunction, SeriesResolutionResult, ServiceCallDataSource, ServiceCallType, ServiceHealthConfigResult, ServiceHealthWidgetConfig, ServicesHealthWidgetConfig, SparklineGeometry, StatColor, StatItem, StaticDataSource, StatsGridConfigResult, StatsGridWidgetConfig, StatusIndicatorConfigResult, StatusIndicatorWidgetConfig, StatusListConfigResult, StatusListWidgetConfig, StreamDataExecutionArgs, SummaryCardConfigResult, SummaryCardTile, SummaryCardWidgetConfig, TableColumn, TableColumnStatusIconMapping, TableConfigResult, TableFilterConfig, TableSortConfig, TableWidgetConfig, TargetEntityWithAttributes, TenantCountWidgetConfig, TimeRangePickerConfig, TimeRangeSelection, TimeRangeType, UpdateDashboardResult, VariableResolutionError, VersionInfoWidgetConfig, WidgetConfig, WidgetConfigDialog, WidgetConfigDialogSize, WidgetConfigResult, WidgetCreationOptions, WidgetDataSource, WidgetFilterConfig, WidgetGroupAttributeMappings, WidgetGroupChildTemplate, WidgetGroupConfig, WidgetGroupConfigResult, WidgetGroupLayout, WidgetPersistenceData, WidgetPositionUpdate, WidgetRegistration, WidgetType, WidgetZone };
+export { ADAPTER_OFFLINE_GRACE_MS, ASSOCIATION_HOP_SOURCE_BATCH, ASSOCIATION_HOP_TARGETS_PER_SOURCE, ATTENTION_SEVERITY_ORDER, AdaptersAttentionProvider, AddWidgetDialogComponent, AiInsightsConfigDialogComponent, AiInsightsService, AiInsightsWidgetComponent, AlertBannerConfigDialogComponent, AlertBannerWidgetComponent, AlertListConfigDialogComponent, AlertListWidgetComponent, AssociationsConfigDialogComponent, AttentionListConfigDialogComponent, AttentionListWidgetComponent, AutoRefreshTimerService, BUILT_IN_ATTENTION_PROVIDERS, BarChartConfigDialogComponent, BarChartWidgetComponent, BlueprintUpdatesAttentionProvider, COCKPIT_ADAPTER_LIMIT, COCKPIT_ATTENTION_PROVIDERS, COCKPIT_BLUEPRINT_CATALOG_LIMIT, COCKPIT_CHILD_TENANT_IDS, COCKPIT_DATA_FLOW_LIMIT, COCKPIT_EXPLAIN_HANDLER, COCKPIT_FAILED_EXECUTIONS_OPTIONS, COCKPIT_KPI_GATES, COCKPIT_KPI_SLOW_LOADING_MS, COCKPIT_LINK_RESOLVER, COCKPIT_RECENT_ITEMS, COCKPIT_ROLES, COCKPIT_SERVICE_NAMES, COCKPIT_VERSION_SOURCE, COCKPIT_VIEWER_ACCESS, COCKPIT_WIDGET_MESSAGES, COCKPIT_WIDGET_TYPES, CkModelsResolveFailedAttentionProvider, CockpitAdapterStatesService, CockpitAttentionService, CockpitBlueprintStatusService, CockpitChildTenantsService, CockpitCkModelStatesService, CockpitContextService, CockpitDataFlowExecutionsService, CockpitKpiConfigDialogComponent, CockpitKpiService, CockpitKpiWidgetComponent, CockpitServiceHealthService, DAY_MS, DEFAULT_ATTENTION_MAX_ITEMS, DEFAULT_COCKPIT_WIDGET_MESSAGES, DEFAULT_FAILED_EXECUTIONS_OPTIONS, DEFAULT_MESHBOARD_MESSAGES, DEFAULT_RECENT_ITEMS_MAX, DEFAULT_TIME_ZONE_MODE, DashboardDataService, DashboardGridService, EditModeStateService, EditWidgetDialogComponent, EntityAssociationsWidgetComponent, EntityCardConfigDialogComponent, EntityCardWidgetComponent, EntityDetailDialogComponent, EntitySelectorEditorComponent, EntitySelectorScopePathEditorComponent, EntitySelectorToolbarComponent, FALLBACK_SERIES_COLORS, FailedExecutionsAttentionProvider, FeaturesNotInstalledAttentionProvider, GaugeConfigDialogComponent, GaugeWidgetComponent, HISTOGRAM_HOURS, HOUR_MS, HeatmapConfigDialogComponent, HeatmapWidgetComponent, KPI_ERROR_TEXT, KpiConfigDialogComponent, KpiWidgetComponent, LazyMarkdownComponent, LineChartConfigDialogComponent, LineChartWidgetComponent, MAX_RECENT_ITEMS, MAX_SCOPE_HOPS, MESHBOARD_CHROME_ROUTE_DATA, MESHBOARD_DESCRIPTION_MARKER, MESHBOARD_EDIT_QUERY_PARAM, MESHBOARD_HEADER_MODE_ROUTE_DATA, MESHBOARD_LABEL_RESOLVER, MESHBOARD_LANGUAGE, MESHBOARD_MESSAGES, MESHBOARD_OPTIONS, MESHBOARD_TENANT_ID_PROVIDER, MarkdownConfigDialogComponent, MarkdownWidgetComponent, MeshBoardDataService, MeshBoardGridService, MeshBoardManagerDialogComponent, MeshBoardPersistenceService, MeshBoardSettingsDialogComponent, MeshBoardSettingsResult, MeshBoardStateService, MeshBoardViewComponent, NOT_AVAILABLE_TEXT, PieChartConfigDialogComponent, PieChartWidgetComponent, QueryExecutorService, QuerySelectorComponent, RecentItemsConfigDialogComponent, RecentItemsWidgetComponent, RuntimeEntitySelectorComponent, SERVICE_MANAGED_BLUEPRINT_PREFIX, STATE_STATUS_BY_KEY, ServiceHealthConfigDialogComponent, ServiceHealthWidgetComponent, ServicesHealthAttentionProvider, StatsGridConfigDialogComponent, StatsGridWidgetComponent, StatusIndicatorConfigDialogComponent, StatusIndicatorWidgetComponent, StatusListConfigDialogComponent, StatusListWidgetComponent, SummaryCardConfigDialogComponent, SummaryCardWidgetComponent, TableConfigDialogComponent, TableWidgetComponent, TableWidgetDataSourceDirective, UnregisteredPoolsAttentionProvider, WidgetFactoryService, WidgetGroupComponent, WidgetGroupConfigDialogComponent, WidgetNotConfiguredComponent, WidgetRegistryService, adapterKpi, adaptersInError, adaptersOffline, blueprintUpdatesKpi, buildHourlyHistogram, categoryStatus, chartSeriesColors, ckModelKpi, classifyQuery, compareBlueprintVersions, compareMeshBoardNavigation, countFlowExecutions, countLabel, countPipelineExecutions, emptyQueryExecutionResult, enabledButNotInstalled, executionKpi, failedExecutionsSeverity, formatCockpitMessage, formatCount, humanizeCategory, isAdapterAtRest, isAdapterExpectedToRun, isAdapterOnline, isCockpitWidgetType, isMeshBoardChrome, isMeshBoardHeaderMode, isServiceConfigured, joinEncodedDescription, kpiKindOf, latestStatisticsUpdate, legacyCockpitLinkTarget, loadNgxMarkdown, nameList, newMeshBoardConfig, normalizeNavigation, observeThemeChanges, parseHostTimeRange, pickLocalizedText, pipelineExecutionInputs, plural, provideCockpitWidgetHost, provideCockpitWidgets, provideDefaultWidgets, provideMeshBoard, provideMeshBoardLanguage, provideMeshBoardMessages, provideProcessWidget, provideWidgetRegistrations, queryFamily, readMeshBoardNavigation, recentRelativeTime, registerCockpitWidgets, registerDefaultWidgets, registerProcessWidget, resolveChartColor, resolveCockpitWidgetMessages, resolveMeshBoardChrome, resolveMeshBoardHeaderMode, resolveMeshBoardLabel, resolveMeshBoardMessages, selectProviders, serviceStateText, servicesHealthKpi, sortAttentionFindings, sparklineGeometry, splitBlueprintId, splitEncodedDescription, statusColor, summarizeAdapterOnline, tenantCountKpi, toBlueprintStatus, toServiceHealthStatus, truncationNote, versionKpi, withMeshBoardNavigation };
+export type { AdapterOnlineFields, AdapterOnlineSummary, AdapterStatusWidgetConfig, AggregationDataSource, AggregationQuery, AggregationType, AiInsightsConfigResult, AiInsightsWidgetConfig, AlertBannerConfigResult, AlertBannerWidgetConfig, AlertListConfigResult, AlertListWidgetConfig, AnyWidgetConfig, AssociationsConfigResult, AttentionContext, AttentionFinding, AttentionLink, AttentionListConfigResult, AttentionListWidgetConfig, AttentionProvider, AttentionProviderInfo, AttentionSeverity, AttentionState, BarChartColorThreshold, BarChartConfigResult, BarChartSeries, BarChartType, BarChartWidgetConfig, BaseWidgetConfig, BlueprintUpdatesWidgetConfig, CategoryStatus, CategoryValueItem, ChartReferenceLine, CkModelStateWidgetConfig, CkQueryResult, CkQueryTarget, CkTypeAttributeInfo, CockpitAdapterState, CockpitAdapterStates, CockpitBlueprintStatus, CockpitBlueprintUpdate, CockpitChildTenants, CockpitCkModelCounts, CockpitDataFlowExecutions, CockpitDataFlowRow, CockpitExecutionCounts, CockpitExplainHandler, CockpitExplainTarget, CockpitKpi, CockpitKpiConfigResult, CockpitKpiKind, CockpitKpiResult, CockpitKpiStatus, CockpitKpiWidgetConfig, CockpitKpiWidgetOptions, CockpitLinkQueryParams, CockpitLinkResolver, CockpitLinkTarget, CockpitRecentItem, CockpitRecentItemKind, CockpitRecentItemsSource, CockpitResolvedLink, CockpitRouteLinkTarget, CockpitServiceHealth, CockpitServiceHealthStatus, CockpitServiceKey, CockpitVersionEntry, CockpitVersionSource, CockpitViewerAccess, CockpitWidgetHost, CockpitWidgetMessages, CockpitWidgetMessagesSource, CockpitWidgetType, ConfigDialogResult, ConfigResultApplier, ConstructionKitQueryDataSource, DashboardConfig, DashboardWidget, DataSource, DataSourceType, DiagramPropertyMapping, EncodedDescription, EntityAssociation, EntityAttribute, EntityCardConfigResult, EntityCardWidgetConfig, EntityListWidget, EntitySelectorAttributeMapping, EntitySelectorChildScope, EntitySelectorClearEvent, EntitySelectorConfig, EntitySelectorEvent, EntitySelectorScopeHop, EntitySelectorScopeState, EntityWidget, EntityWithAssociationsWidgetConfig, FailedExecutionsAttentionOptions, GaugeConfigResult, GaugeRange, GaugeType, GaugeWidgetConfig, GridCell, GridPosition, GroupChildWidgetType, GroupedDataItem, HeatmapAggregation, HeatmapColorMode, HeatmapColorScheme, HeatmapConfigResult, HeatmapWidgetConfig, HostTimeRangeState, HourlyExecutionBucket, HourlyHistogramOptions, KpiConfigResult, KpiDataSourceType, KpiQueryMode, KpiValueMode, KpiWidgetConfig, LatestExecutionInput, LineChartConfigResult, LineChartType, LineChartWidgetConfig, MarkdownConfigResult, MarkdownTextAlign, MarkdownWidgetConfig, MeshBoardChrome, MeshBoardConfig, MeshBoardHeaderMode, MeshBoardHostTimeRange, MeshBoardLabelKind, MeshBoardLabelRequest, MeshBoardLabelResolver, MeshBoardLanguageSource, MeshBoardMessages, MeshBoardMessagesSource, MeshBoardNavigationConfig, MeshBoardOptions, MeshBoardTimeFilterConfig, MeshBoardTimeFilterControl, MeshBoardTimeZoneMode, MeshBoardVariable, MeshBoardVariableSource, MeshBoardVariableType, ParentAssociationMode, PersistedDashboard, PersistedMeshBoard, PersistedWidget, PersistedWidgetData, PersistentQueryCellMode, PersistentQueryCellSource, PersistentQueryDataSource, PersistentQueryItem, PieChartConfigResult, PieChartLabelPosition, PieChartType, PieChartWidgetConfig, PipelineExecutionCounts, PipelineExecutionInput, PipelineExecutionsWidgetConfig, PipelineStatisticsInput, ProcessWidgetConfig, Quarter, QueryCell, QueryClassification, QueryColumn, QueryColumnInfo, QueryColumnItem, QueryExecutionOptions, QueryExecutionResult, QueryFamily, QueryKind, QueryResultRow, RawHourBucket, RecentItemsConfigResult, RecentItemsWidgetConfig, RelativeTimeUnit, RepeaterDataItem, RepeaterQueryDataSource, RuntimeEntityData, RuntimeEntityDataSource, RuntimeEntitySelectorValue, SeriesAggregationFunction, SeriesResolutionResult, ServiceCallDataSource, ServiceCallType, ServiceHealthConfigResult, ServiceHealthWidgetConfig, ServicesHealthWidgetConfig, SparklineGeometry, StatColor, StatItem, StaticDataSource, StatsGridConfigResult, StatsGridWidgetConfig, StatusIndicatorConfigResult, StatusIndicatorWidgetConfig, StatusListConfigResult, StatusListWidgetConfig, StreamDataExecutionArgs, StreamDataScope, SummaryCardConfigResult, SummaryCardTile, SummaryCardWidgetConfig, TableColumn, TableColumnStatusIconMapping, TableColumnValueLabel, TableConfigResult, TableFilterConfig, TableSortConfig, TableWidgetConfig, TargetEntityWithAttributes, TenantCountWidgetConfig, TimeRangePickerConfig, TimeRangeSelection, TimeRangeType, UpdateDashboardResult, VariableResolutionError, VersionInfoWidgetConfig, WidgetConfig, WidgetConfigDialog, WidgetConfigDialogSize, WidgetConfigResult, WidgetCreationOptions, WidgetDataSource, WidgetFilterConfig, WidgetGroupAttributeMappings, WidgetGroupChildTemplate, WidgetGroupConfig, WidgetGroupConfigResult, WidgetGroupLayout, WidgetPersistenceData, WidgetPositionUpdate, WidgetRegistration, WidgetType, WidgetZone };