@overvis/hmi-workspace-ui 0.0.0-stage → 0.1.0

package/dist/src/workspace/no-access.d.ts

@@ -0,0 +1 @@
+export declare function NoAccessPage(): import("react").JSX.Element;

package/dist/src/workspace/page-navigation.d.ts

@@ -0,0 +1,67 @@
+import { type RefObject } from "react";
+import { type AnyRoute, type HistoryState } from "@tanstack/react-router";
+declare module "@tanstack/react-router" {
+    interface HistoryState {
+        /** The path whose scroll position the page area keeps on the step to this entry. */
+        overvisKeepScrollFrom?: string;
+    }
+}
+/**
+ * History state for a navigation from `pathname` that keeps the page area's scroll position
+ * although it opens another page, such as an overlay at its own path. Pass it as `state` with
+ * `resetScroll: false`.
+ */
+export declare function keepScrollState(pathname: string): HistoryState;
+interface HistoryEntry {
+    pathname: string;
+    state: HistoryState & {
+        __TSR_index: number;
+    };
+}
+/**
+ * Whether moving between history entries keeps the scroll position: only between an entry opened
+ * with `keepScrollState` and the path it was opened from, forward (opening it, Forward) or
+ * backward (Back out of it). A jump across other pages resets it.
+ */
+export declare function keepsScrollPosition(from: HistoryEntry | undefined, to: HistoryEntry): boolean;
+/**
+ * Marks `route` as a list whose child routes open as dialogs over it. The list stays the page
+ * while they open and close, so `useScrollToTopOnPageChange` keeps its scroll position.
+ */
+export declare function hostsDialogRoutes<TRoute extends AnyRoute>(route: TRoute): TRoute;
+/**
+ * Whether the router is still loading a different page while it shows the previous one. Query,
+ * anchor and dashboard subpage-state updates on the same page do not count.
+ */
+export declare function isNavigatingToAnotherPage(state: {
+    status: "pending" | "idle";
+    location: {
+        pathname: string;
+    };
+    resolvedLocation?: {
+        pathname: string;
+    } | undefined;
+}): boolean;
+/**
+ * The page the router shows: the first matched route `isDialogHost` accepts, so its dialog routes
+ * belong to it, or else the path. Undefined while a navigation is pending: the router commits the
+ * new matches before it marks their location resolved.
+ */
+export declare function shownPage(state: {
+    status: "pending" | "idle";
+    matches: readonly {
+        id: string;
+        routeId: string;
+    }[];
+    resolvedLocation?: {
+        pathname: string;
+    } | undefined;
+}, isDialogHost: (routeId: string) => boolean): string | undefined;
+/**
+ * Scrolls `area` to the top once the router shows another page, as browsers do for the window.
+ * Query changes on the same page keep the position, and a link to an anchor scrolls to the anchor.
+ * Dialog routes of a `hostsDialogRoutes` list belong to the list's page, and navigations opened
+ * with `keepScrollState` keep the position too (see `keepsScrollPosition`).
+ */
+export declare function useScrollToTopOnPageChange(area: RefObject<HTMLElement | null>): void;
+export {};

package/dist/src/workspace/page-state/branch-path.d.ts

@@ -0,0 +1,7 @@
+import type { ParameterTreeBranch } from "@overvis/hmi-shared/parameter";
+/** Root-first localized branch names from the parameter's branch to the tree root. */
+export declare function localizedBranchPath(input: {
+    branchId: string;
+    branchesById: ReadonlyMap<string, ParameterTreeBranch>;
+    locale: string;
+}): string[];

package/dist/src/workspace/page-state/context.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+import type { UiPageState } from "./model.js";
+import type { UiPageStateGetter, UiPageStateStore } from "./store.js";
+export declare function UiPageStateProvider({ store, children, }: {
+    store: UiPageStateStore;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Publish this page's live state to the host while mounted. No-op outside a workspace host. */
+export declare function usePublishUiPageState(id: string, getState: UiPageStateGetter): void;
+/**
+ * Stable reader for the host's page state: the one publishing page's live state, or `null` when
+ * none or more than one page publishes (or no workspace host is mounted).
+ */
+export declare function useUiPageStateReader(): () => Promise<UiPageState | null>;

package/dist/src/workspace/page-state/dashboard-context.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from "react";
+import type { UiPageState, UiPageStateDashboardSummary } from "./model.js";
+/** Builds the summary on request; may read values first. */
+export type DashboardSummaryGetter = () => UiPageStateDashboardSummary | Promise<UiPageStateDashboardSummary>;
+interface DashboardSummarySlot {
+    publish: (getSummary: DashboardSummaryGetter) => () => void;
+    /** The one publishing page's summary, or null when none or more than one publishes. */
+    read: () => Promise<UiPageStateDashboardSummary | null>;
+}
+export declare function createDashboardSummarySlot(): DashboardSummarySlot;
+interface DashboardPageIdentity {
+    dashboardId: string;
+    title: string;
+    path: string;
+}
+/**
+ * The open dashboard page with the summary built for `before`. A dashboard or page that changed
+ * while the summary was built publishes its location without it.
+ */
+export declare function dashboardPageState(before: DashboardPageIdentity, after: DashboardPageIdentity, summary: UiPageStateDashboardSummary | null): Extract<UiPageState, {
+    kind: "dashboard";
+}>;
+/**
+ * Publishes the open dashboard to the host's page state: its id, title, location, and the summary
+ * its current page publishes. Summaries are built only when the host asks.
+ */
+export declare function DashboardPageStatePublisher({ dashboardId, title, children, }: {
+    dashboardId: string;
+    title: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Publish what this dashboard page shows, for the assistant to read on request. `getSummary` runs
+ * only then, with the values of the latest render. No-op outside a mounted dashboard.
+ */
+export declare function usePublishDashboardSummary(getSummary: DashboardSummaryGetter): void;
+export {};

package/dist/src/workspace/page-state/dashboard.d.ts

@@ -0,0 +1,65 @@
+import { type SiteAlarmSeverity } from "@overvis/hmi-shared/dashboard";
+import type { SiteStatus } from "@overvis/hmi-shared/dashboard";
+import type { ParameterCondition } from "@overvis/hmi-shared/parameter";
+import { type SiteState } from "../fleet/status.js";
+import type { ParameterValueState } from "../parameters/live/model.js";
+import type { UiPageStateDashboardSummary } from "./model.js";
+/** What a summary needs of a site's evaluated state, such as an `evaluateSiteStatus` result. */
+export type SiteSummaryState = Pick<SiteState, "status" | "alarmUnknown">;
+/** A site's maintenance as a dashboard summary lists it. */
+export interface SiteMaintenanceSummary {
+    /** Equipment names whose maintenance date has passed. */
+    overdue: readonly string[];
+    /** Some maintenance date is unavailable. */
+    unknown: boolean;
+}
+/** A known active alarm or fault of one site, as a dashboard summary lists it. */
+export interface SiteActiveAlarm {
+    /** Equipment that raised it, such as a pump; null for a site-level alarm. */
+    equipment: string | null;
+    name: string;
+    severity: SiteAlarmSeverity;
+}
+/** A named alarm condition, as a site or device page binds it. */
+export interface SiteAlarmBinding extends SiteActiveAlarm {
+    condition: ParameterCondition;
+}
+/** The alarms of `bindings` known to be active, in their order. */
+export declare function activeSiteAlarms(bindings: readonly SiteAlarmBinding[], states: ReadonlyMap<string, ParameterValueState>): SiteActiveAlarm[];
+type FleetSummary = Extract<UiPageStateDashboardSummary, {
+    kind: "fleet";
+}>;
+type SiteSummary = Extract<UiPageStateDashboardSummary, {
+    kind: "site";
+}>;
+/**
+ * Fleet summary over every site, ignoring the overview's filters: status totals, active alarms
+ * critical first, and sites most urgent first (within a status, overdue maintenance or unreadable
+ * feedback first). The unreadable-feedback counts cover every site, listed or not.
+ */
+export declare function buildFleetSummary<Site extends {
+    id: string;
+    name: string;
+}>(input: {
+    sites: readonly Site[];
+    stateOf: (site: Site) => SiteSummaryState;
+    statusLabel: (status: SiteStatus) => string;
+    alarmsOf?: (site: Site) => readonly SiteActiveAlarm[];
+    maintenanceOf?: (site: Site) => SiteMaintenanceSummary;
+}): FleetSummary;
+/**
+ * Summary of one site page: its status and active alarms, critical first, and optionally the whole
+ * fleet (a `buildFleetSummary` result) for questions about other sites.
+ */
+export declare function buildSiteSummary(input: {
+    site: {
+        id: string;
+        name: string;
+    };
+    state: SiteSummaryState;
+    statusLabel: (status: SiteStatus) => string;
+    alarms: readonly SiteActiveAlarm[];
+    maintenance?: SiteMaintenanceSummary;
+    fleet?: FleetSummary;
+}): SiteSummary;
+export {};

package/dist/src/workspace/page-state/model.d.ts

@@ -0,0 +1,48 @@
+import { type LocalizedString } from "@overvis/hmi-shared";
+import type { DashboardPageSummary, DashboardPageSummaryAlarm, DashboardPageSummaryFleet, DashboardPageSummarySite } from "@overvis/hmi-shared/dashboard";
+export declare function resolvedOptionalLabel(value: LocalizedString | null | undefined, locale: string): string | null;
+export interface UiPageStateParameter {
+    id: string;
+    name: string;
+    units: string | null;
+    valueType: string;
+    /** Root-first parent branch names. Empty when the page has no tree (report session). */
+    branchPath: string[];
+}
+export interface UiPageStateBranch {
+    id: string;
+    name: string;
+}
+export interface UiPageStateRepresentation {
+    key: string;
+    type: string;
+}
+export type UiPageStateAlarm = DashboardPageSummaryAlarm;
+export type UiPageStateSite = DashboardPageSummarySite;
+export type UiPageStateFleet = DashboardPageSummaryFleet;
+export type UiPageStateDashboardSummary = DashboardPageSummary;
+export type UiPageState = {
+    kind: "parameters";
+    selectedParameters: UiPageStateParameter[];
+    selectedBranches: UiPageStateBranch[];
+} | {
+    kind: "report";
+    presetId: string;
+    title: string;
+    from: number;
+    to: number;
+    fromIso: string;
+    toIso: string;
+    timeZone: string;
+    followLive: boolean;
+    visibleParameters: UiPageStateParameter[];
+    representations: UiPageStateRepresentation[];
+} | {
+    kind: "dashboard";
+    dashboardId: string;
+    title: string;
+    /** Location inside the dashboard, such as `/stations/<id>`. */
+    path: string;
+    /** Null when the open dashboard page publishes no summary. */
+    summary: UiPageStateDashboardSummary | null;
+};

package/dist/src/workspace/page-state/parameters.d.ts

@@ -0,0 +1,11 @@
+import type { Parameter, ParameterTreeBranch } from "@overvis/hmi-shared/parameter";
+import type { ParamTreeSelectionSnapshot } from "../setup/parameters/selection.js";
+import { type UiPageState } from "./model.js";
+export declare function buildParametersPageState(input: {
+    selection: ParamTreeSelectionSnapshot;
+    parameters: readonly Parameter[];
+    branches: readonly ParameterTreeBranch[];
+    locale: string;
+}): Extract<UiPageState, {
+    kind: "parameters";
+}>;

package/dist/src/workspace/page-state/report.d.ts

@@ -0,0 +1,16 @@
+import { type ReportParameterSetup, type ReportPreset } from "@overvis/hmi-shared/report";
+import type { ReportMountedWidget } from "../reports/html/mounted.js";
+import { type UiPageState } from "./model.js";
+export declare function buildReportPageState(input: {
+    preset: ReportPreset;
+    from: number;
+    to: number;
+    timeZone: string;
+    followLive: boolean;
+    visibleParameterIds: ReadonlySet<string>;
+    parametersById: ReadonlyMap<string, ReportParameterSetup>;
+    mountedWidgets: readonly ReportMountedWidget[];
+    locale: string;
+}): Extract<UiPageState, {
+    kind: "report";
+}>;

package/dist/src/workspace/page-state/store.d.ts

@@ -0,0 +1,10 @@
+import type { UiPageState } from "./model.js";
+/** A page's live state; a page that must read values first resolves it later. */
+export type UiPageStateGetter = () => UiPageState | Promise<UiPageState>;
+export interface UiPageStateStore {
+    /** Publish a page's live state under `id`. Returns a function that withdraws it. */
+    publish: (id: string, getState: UiPageStateGetter) => () => void;
+    /** Live UI state from the one publishing page, or `null` if none or more than one. */
+    read: () => Promise<UiPageState | null>;
+}
+export declare function createUiPageStateStore(): UiPageStateStore;

package/dist/src/workspace/parameters/defaults.d.ts

@@ -0,0 +1,7 @@
+import type { ParameterFormCalcSource, ParameterFormSource, ParameterSource } from "@overvis/hmi-shared/parameter";
+/** Form-friendly calc defaults: empty placeholder row, never a fake UUID. */
+export declare function defaultCalcSource(): ParameterFormCalcSource;
+export declare function defaultModbusSource(endpointId: string): Extract<ParameterSource, {
+    kind: "modbus-tcp";
+}>;
+export declare function defaultSource(endpointId: string | null): ParameterFormSource;

package/dist/src/workspace/parameters/display.d.ts

@@ -0,0 +1,28 @@
+import type { Parameter } from "@overvis/hmi-shared/parameter";
+/** Register addresses as a range, such as `1024-1025`, or a list when they are not consecutive. */
+export declare function formatModbusAddressSpan(addresses: number[]): string;
+/** Short Modbus table label used beside register addresses. */
+export declare function modbusTableListLabel(table: "coil" | "discrete-input" | "holding-register" | "input-register"): string;
+export interface ParameterListParts {
+    mnemonic: string | null;
+    name: string;
+    units: string | null;
+}
+export interface ParameterDetailParts {
+    description: string | null;
+    metaLine: string;
+    tags: string[];
+}
+export declare function getParameterListParts(param: Parameter, locale?: "de" | "en" | "pl" | "ru" | "uk"): ParameterListParts;
+export type BackgroundReadingPeriodCompactUnit = "s" | "m" | "h";
+/** Period to show on the Setup tree chip, or null when hidden (Off or unset). */
+export declare function backgroundReadingPeriodMsForChip(disabled: boolean, backgroundReadingPeriodMs: number | null): number | null;
+export declare function backgroundReadingPeriodCompactParts(periodMs: number): {
+    n: number;
+    unit: BackgroundReadingPeriodCompactUnit;
+};
+export declare function formatBackgroundReadingPeriodCompact(periodMs: number): string;
+export declare function backgroundReadingPeriodAriaLabel(periodMs: number): string;
+export declare function getParameterDetailParts(param: Parameter, endpointNameById: Map<string, string>): ParameterDetailParts;
+/** True when any locale value (or plain string) contains the query (case-insensitive). */
+export declare function localizedFieldMatches(value: Parameter["name"] | Parameter["mnemonic"] | null | undefined, queryLower: string): boolean;

package/dist/src/workspace/parameters/distinct-names.d.ts

@@ -0,0 +1,12 @@
+import { type AppLocale } from "@overvis/hmi-shared";
+/** What `useDistinctParameterNames` reads of a parameter, as `parameter.get` returns it. */
+export interface DistinctNameParameter {
+    name: string;
+    branchId: string;
+}
+/**
+ * Names for parameters shown together, such as the lines of a chart: each parameter's name, with
+ * its branch's name in front where two would read the same ("Channel 1 · Temperature"). An empty
+ * string for a parameter not loaded yet; its position number while a branch name loads.
+ */
+export declare function useDistinctParameterNames(parameters: readonly (DistinctNameParameter | null)[], locale: AppLocale): string[];

package/dist/src/workspace/parameters/errors.d.ts

@@ -0,0 +1,15 @@
+/** Parameter form fields for codes the API sends without `details.field`. */
+export declare const parameterCodeFields: {
+    readonly parameter_name_invalid: "name";
+    readonly parameter_invalid_value_type: "valueType";
+    readonly parameter_branch_not_found: "branchId";
+    readonly parameter_endpoint_not_found: "source";
+    readonly parameter_input_not_found: "source";
+    readonly parameter_input_self_reference: "source";
+    readonly parameter_input_cycle: "source";
+};
+/**
+ * Source field text for a save rejected because the Modbus addresses supply fewer bytes than the
+ * value type needs (`modbus_source_too_short`), or null for any other failure.
+ */
+export declare function modbusSourceTooShortError(error: unknown): (() => string) | null;

package/dist/src/workspace/parameters/form/shared-fields.d.ts

@@ -0,0 +1,49 @@
+import type { ExpressionDiagnostic } from "@overvis/hmi-shared/expression";
+import type { Parameter, ParameterByteRelation } from "@overvis/hmi-shared/parameter";
+/** A formula input that shows the first problem of the formula, translated, as it is typed. */
+export declare function FormulaField({ id, label, value, problem, onChange, }: {
+    id: string;
+    label: string;
+    value: string;
+    problem: ExpressionDiagnostic | undefined;
+    onChange: (next: string) => void;
+}): import("react").JSX.Element;
+export declare function TagsListEditor({ tags, errors, onChange, }: {
+    tags: string[];
+    errors: {
+        message?: string;
+    }[];
+    onChange: (next: string[]) => void;
+}): import("react").JSX.Element;
+export declare function ParameterSearchSelect({ value, options, onChange, }: {
+    value: string;
+    options: Parameter[];
+    onChange: (id: string) => void;
+}): import("react").JSX.Element;
+export declare function ByteRelationFields({ value, onChange, }: {
+    value: ParameterByteRelation;
+    onChange: (next: ParameterByteRelation) => void;
+}): import("react").JSX.Element;
+export declare function OptionalNumberInput({ id, label, value, integer, description, onChange, }: {
+    id: string;
+    label: string;
+    value: number | null;
+    integer?: boolean;
+    description?: string;
+    onChange: (next: number | null) => void;
+}): import("react").JSX.Element;
+export declare function TransformFields({ transform, onChange, }: {
+    transform: {
+        fromRead: string;
+        toWrite: string | null;
+    } | null;
+    onChange: (next: {
+        fromRead: string;
+        toWrite: string | null;
+    } | null) => void;
+}): import("react").JSX.Element;
+export declare function AllowedValuesEditor({ values, digitOnly, onChange, }: {
+    values: string[] | null;
+    digitOnly: boolean;
+    onChange: (next: string[] | null) => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/parameters/form/values.d.ts

@@ -0,0 +1,33 @@
+import { type FormInputProblem } from "@overvis/hmi-shared";
+import type { EndpointListItem } from "@overvis/hmi-shared/endpoint";
+import { type ParameterFormProblem, type ParameterFormSource, type ParameterFormValues, type ParameterTreeBranch, type ParameterValueType } from "@overvis/hmi-shared/parameter";
+export declare const ICON_NONE = "__none__";
+export declare const VALUE_TYPE_NAMES: readonly ["str", "num", "int", "bool", "bigint", "datetime", "ipaddr", "macaddr", "geo"];
+export declare const DATETIME_COMPOSITION_KINDS: readonly ["timestamp-sec-32", "timestamp-msec-32", "timestamp-days-32", "timestamp-days-16", "iso-8601-string", "datetime"];
+export declare const NUMERIC_PACKINGS: readonly ["unsigned-int", "signed-int", "bcd-int", "float16", "float32", "float64", "decimal16", "decimal32", "decimal64"];
+export declare const INT_BYTE_PACKINGS: readonly ["unsigned-int", "signed-int", "bcd"];
+export declare const GEO_PACKINGS: readonly ["unsigned-int", "signed-int", "float32", "float64"];
+export declare const STR_ENCODINGS: readonly ["ascii", "utf8", "utf16le", "base64", "hex"];
+export interface BranchOption {
+    id: string;
+    label: string;
+    depth: number;
+}
+export declare function buildBranchOptions(branches: ParameterTreeBranch[], locale: string): BranchOption[];
+export declare function parseOptionalNumber(text: string): number | null;
+export declare function parseOptionalInt(text: string): number | null;
+type ParameterFormInputProblem = FormInputProblem<"source" | "valueType", ParameterFormProblem>;
+/** Current-locale text for a failed parameter form conversion. */
+export declare function parameterFormProblemMessage(result: ParameterFormInputProblem): string;
+export declare function isWritableModbusTable(table: string): table is "coil" | "holding-register";
+export declare function sourceForKind(kind: ParameterFormSource["kind"], endpointId: string | null): ParameterFormSource;
+export declare function withModbusTable(source: Extract<ParameterFormSource, {
+    kind: "modbus-tcp";
+}>, table: Extract<ParameterFormSource, {
+    kind: "modbus-tcp";
+}>["table"]): ParameterFormSource;
+export declare function defaultDatetimeComposition(kind: (typeof DATETIME_COMPOSITION_KINDS)[number]): Extract<ParameterValueType, {
+    name: "datetime";
+}>["composition"];
+export declare function createDefaultValues(branches: ParameterTreeBranch[], endpoints: EndpointListItem[], initialBranchId: string | undefined): ParameterFormValues;
+export {};

package/dist/src/workspace/parameters/geo-value.d.ts

@@ -0,0 +1,9 @@
+/** Parse canonical geo `"lat,lon"` decimal degrees. Returns null if invalid. */
+export declare function parseGeoCanonical(value: string): {
+    lat: number;
+    lon: number;
+} | null;
+/** Format for draft commit; prefer the live display string when values match it. */
+export declare function formatGeoCanonical(lat: number, lon: number): string;
+/** True when draft lat/lon match the currently displayed canonical geo string. */
+export declare function geoDraftMatchesDisplay(lat: number, lon: number, displayValue: string): boolean;

package/dist/src/workspace/parameters/icon.d.ts

@@ -0,0 +1,8 @@
+/** Lucide kebab-case ids offered in the parameter form picker (process / signal oriented). */
+export declare const PARAMETER_ICON_IDS: readonly ["gauge", "thermometer", "droplets", "wind", "flame", "zap", "fan", "binary", "activity", "arrow-up-down", "rotate-cw", "percent", "timer", "bell", "power"];
+/** Renders a Lucide glyph when icon id is set; otherwise a same-size spacer for alignment. */
+export declare function ParameterIconGlyph({ icon, className, strokeWidth, }: {
+    icon: string | null | undefined;
+    className?: string;
+    strokeWidth?: number;
+}): import("react").JSX.Element;

package/dist/src/workspace/parameters/inventory-options.d.ts

@@ -0,0 +1,9 @@
+export interface InventoryParameterOption {
+    id: string;
+    label: string;
+    path: string;
+}
+export declare function inventoryTreeRecord(value: unknown): Record<string, unknown>;
+export declare function inventoryFromQueryData(data: unknown): InventoryParameterOption[];
+/** Flatten inventory tree: object values are branches, string values are parameters (UUID keys). */
+export declare function flattenInventoryParameters(tree: Record<string, unknown>, prefix?: readonly string[]): InventoryParameterOption[];

package/dist/src/workspace/parameters/live/condition.d.ts

@@ -0,0 +1,4 @@
+import { type ParameterCondition } from "@overvis/hmi-shared/parameter";
+import { type ParameterValueState } from "./model.js";
+/** Unknown, stale, diagnostic, and nonnumeric readings never become a current boolean. */
+export declare function evaluateParameterCondition(condition: ParameterCondition | undefined, states: ReadonlyMap<string, ParameterValueState>): boolean | null;

package/dist/src/workspace/parameters/live/control-button.d.ts

@@ -0,0 +1,13 @@
+import { type AppLocale } from "@overvis/hmi-shared";
+import { type ParameterControl } from "@overvis/hmi-shared/parameter";
+import type { ParameterValueState } from "./model.js";
+import { type ParameterValueEditorMessages } from "./value-editor.js";
+export declare function ParameterControlButton({ messages, control, states, locale, onAcknowledged, disabled, }: {
+    messages: ParameterValueEditorMessages;
+    control: ParameterControl;
+    states: ReadonlyMap<string, ParameterValueState>;
+    locale: AppLocale;
+    onAcknowledged: () => void;
+    /** Shows the control without letting it write, such as in a preview or edit mode. */
+    disabled?: boolean;
+}): import("react").JSX.Element;

package/dist/src/workspace/parameters/live/controls.d.ts

@@ -0,0 +1,14 @@
+import type { ReactElement } from "react";
+import { type ParameterValuesDemandSnapshot } from "./model.js";
+/**
+ * Last update time, status and a pause/resume toggle for a live dashboard. The `compact`
+ * variant is a single pill with a live dot, the time and an icon-only toggle; it leaves
+ * diagnostics to the page.
+ */
+export declare function ParameterLiveControls({ live, summary, onLiveChange, variant, className, }: {
+    live: boolean;
+    summary: ParameterValuesDemandSnapshot;
+    onLiveChange: (live: boolean) => void;
+    variant?: "default" | "compact";
+    className?: string;
+}): ReactElement;

package/dist/src/workspace/parameters/live/coordinator.d.ts

@@ -0,0 +1,87 @@
+import type { ParameterReadValuesStreamEvent, ParameterWriteValuesInput, ParameterWriteValuesOutput } from "@overvis/hmi-shared/parameter";
+import { type WorkspaceAccess } from "@overvis/hmi-shared/workspace";
+import { type ParameterValueState } from "./model.js";
+export interface ParameterValuesTransport {
+    read: (parameterIds: readonly string[], signal: AbortSignal) => Promise<AsyncIterable<ParameterReadValuesStreamEvent>>;
+    write: (input: ParameterWriteValuesInput) => Promise<ParameterWriteValuesOutput>;
+}
+type Listener = () => void;
+export declare class ParameterValuesCoordinator {
+    private transport;
+    private access;
+    private visible;
+    private readonly states;
+    private readonly listenersByParameter;
+    private readonly allListeners;
+    private readonly demands;
+    private activeIntervals;
+    private readonly manualIds;
+    private readonly dueAt;
+    private readonly failureAttempts;
+    private readonly suspendedIds;
+    private readonly versions;
+    private readonly pendingWrites;
+    private timer;
+    private inFlight;
+    private revision;
+    private notificationTimer;
+    private stopped;
+    /** The ordered write sequence running now; the next waits for it. */
+    private sequenceTail;
+    constructor(input: {
+        transport: ParameterValuesTransport;
+        access: WorkspaceAccess;
+    });
+    setTransport(transport: ParameterValuesTransport): void;
+    setAccess(access: WorkspaceAccess): void;
+    setVisible(visible: boolean): void;
+    isPaused(): boolean;
+    getRevision: () => number;
+    subscribeAll: (listener: Listener) => (() => void);
+    subscribeParameter(parameterId: string, listener: Listener): () => void;
+    getState(parameterId: string): ParameterValueState;
+    registerDemand(key: object, input: {
+        parameterIds: readonly string[];
+        intervalMs: number;
+        enabled: boolean;
+    }): void;
+    unregisterDemand(key: object): void;
+    refresh(parameterIds: readonly string[]): void;
+    /**
+     * Read demanded parameters in the next batch, ahead of a retry delay, without keeping them
+     * read once demand ends. A suspended parameter stays suspended. Returns the ones scheduled.
+     */
+    readNow(parameterIds: readonly string[]): ReadonlySet<string>;
+    retry(parameterIds: readonly string[]): void;
+    /**
+     * Runs ordered write sequences one at a time, in the order they start, so the steps of two
+     * sequences, such as a device unlock and the writes it allows, never interleave.
+     */
+    runSequence<T>(sequence: () => Promise<T>): Promise<T>;
+    /**
+     * Writes the items, then reads the written parameters again, except those in `writeOnly`,
+     * such as a device password that must never be read back.
+     */
+    writeValues(input: ParameterWriteValuesInput, options?: {
+        writeOnly?: readonly string[];
+    }): Promise<ParameterWriteValuesOutput>;
+    stop(): void;
+    start(): void;
+    private reconcileDemand;
+    private demandedIntervals;
+    private schedule;
+    private runDueRead;
+    private applyReadResult;
+    private setNextDue;
+    private applyDiagnostic;
+    private markStale;
+    private markRefreshing;
+    private clearRefreshing;
+    private updateSaving;
+    private setState;
+    private notifyAll;
+    private bumpVersion;
+    private clearTimer;
+    private cancelRead;
+}
+export {};

package/dist/src/workspace/parameters/live/deadline.d.ts

@@ -0,0 +1,13 @@
+import { type AppLocale } from "@overvis/hmi-shared";
+import { type ParameterValueState } from "./model.js";
+import { type ParameterValueEditorMessages } from "./value-editor.js";
+export declare function ParameterDeadline({ label, overdueLabel, editLabel, messages, parameterId, state, locale, onAcknowledged, }: {
+    label: string;
+    overdueLabel: string;
+    editLabel: string;
+    messages: ParameterValueEditorMessages;
+    parameterId: string;
+    state: ParameterValueState;
+    locale: AppLocale;
+    onAcknowledged: () => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/parameters/live/diagnostic-copy.d.ts

@@ -0,0 +1,26 @@
+import type { ParameterDiagnostic, ParameterDiagnosticKind } from "./model.js";
+export declare function parameterDiagnosticCopy(kind: ParameterDiagnosticKind): {
+    title: string;
+    description: string;
+};
+/** A labelled fact in a diagnostic's technical details. */
+export interface ParameterDiagnosticDetail {
+    label: string;
+    value: string;
+}
+/** What one diagnostic notice says: a device-aware title, what to check, and the facts. */
+export interface ParameterDiagnosticSummary {
+    title: string;
+    description: string;
+    /** The specific error in a sentence, when it adds to the description. */
+    detail: string | null;
+    /** The device the diagnostic concerns, when the title does not already name it. */
+    subject: string | null;
+    /** Technical facts: the error's name, the affected parameters, and the addresses. */
+    details: ParameterDiagnosticDetail[];
+}
+/**
+ * Describe a diagnostic for its alert. `endpointName` is the name of the endpoint the diagnostic
+ * names, when known, so that a fleet overview tells which device failed.
+ */
+export declare function parameterDiagnosticSummary(diagnostic: ParameterDiagnostic, endpointName: string | null): ParameterDiagnosticSummary;

package/dist/src/workspace/parameters/live/diagnostic-links.d.ts

@@ -0,0 +1,5 @@
+import type { ParameterDiagnostic } from "./model.js";
+/** Read a non-empty string parameter from a diagnostic. */
+export declare function parameterDiagnosticString(diagnostic: ParameterDiagnostic, key: string): string | null;
+export declare function endpointSettingsHref(workspaceId: string, endpointId: string): string;
+export declare function endpointStatusHref(workspaceId: string, endpointId: string): string;