@devicechain/dashboards 0.14.0-0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright The DeviceChain Authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,112 @@
+<!--
+Copyright The DeviceChain Authors
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# @devicechain/dashboards
+
+The DeviceChain dashboard runtime: the **DashboardHub**, which multiplexes live
+telemetry, alarms, commands and locations over the client wire, and the typed
+**dashboard-definition** contract that describes a board.
+
+No React, no rendering. This is the layer under a widget set — the DeviceChain
+console and the standalone `/dash` viewer both sit on it, and so can yours.
+[`@devicechain/widgets`](https://www.npmjs.com/package/@devicechain/widgets) is
+the React widget set built on this package.
+
+```bash
+npm install @devicechain/dashboards @devicechain/client graphql
+```
+
+`@devicechain/client` and `graphql` are peer dependencies. Peers rather than
+ordinary dependencies on purpose: the hub classifies stream errors with
+`instanceof` against the SDK's error type, and `instanceof` is false across two
+copies of the same package — a duplicate would turn "you may not view this
+device" into what reads like an outage.
+
+## The hub
+
+One hub serves a whole board. Widgets subscribe to it; it does the deduplication.
+
+```ts
+import { DashboardHub } from '@devicechain/dashboards';
+
+const hub = new DashboardHub({
+  resolver,                 // how a selector becomes device tokens
+  bindings,                 // slot name -> concrete entity, for templated boards
+  authorities: user.scopes, // what this viewer may do; drives hub.can(...)
+});
+
+const stop = hub.subscribeWidget(widget.datasource, {
+  next: (sample) => setLatest(sample),
+});
+
+// later
+stop();
+hub.disposeAll();
+```
+
+Ten widgets pointed at the same device open **one** upstream subscription, not
+ten. Each widget declares the measurement names it cares about (none means all),
+and the hub fans a single stream out to the subscribers that asked for each name.
+
+Four channels, each with its own `subscribe*` method and disposer:
+
+| channel | what it carries |
+| --- | --- |
+| `subscribeWidget` | measurement samples for a datasource selector |
+| `subscribeAlarms` | live alarm rows, plus `acknowledgeAlarm` / `clearAlarm` |
+| `subscribeCommands` | command rows and their delivery status, plus dispatch |
+| `subscribeLocations` | position series for map widgets |
+
+`disposeAll()` tears down every open channel — a host calls it when the board
+closes, which is what keeps a poll and a socket from outliving the page.
+
+## The definition contract
+
+A dashboard is JSON. The server stores it opaquely; this package is what gives it
+a shape.
+
+```ts
+import { parseDashboardDefinition, serializeDefinition } from '@devicechain/dashboards';
+
+const board = parseDashboardDefinition(json); // throws DashboardDefinitionError
+```
+
+Parsing is validating: a malformed board fails here, in your code, rather than
+half-rendering later. `isDirty` compares a working copy against its saved
+original, `resolveWidgetBox` and `activeBreakpoint` resolve responsive layout,
+and the `editor-model` transforms (`addWidget`, `setWidgetBox`, `deleteWidget`,
+`bringToFront`, …) are pure functions an authoring UI can wire to drag and resize.
+
+## Slots
+
+A board can be written once and pointed at many entities. A widget's datasource
+may name a **slot** instead of a device, and the host supplies a binding for that
+slot at view time — `effectiveBindings`, `resolveContextBindings`,
+`applySelection` and `resolveSlotCandidates` are the machinery, and
+`hub.setBindings()` rebinds a live board.
+
+## Synthetic data
+
+`SyntheticDataSource` implements the same interface as the hub and generates
+plausible measurements, so a board can be previewed, screenshotted or
+demonstrated with no instance behind it.
+
+## Command status
+
+`isTerminalCommandStatus` and `isCancellableCommandStatus` are the two questions
+worth asking about a command, and they are different questions — a `SENT` command
+is still in flight but is no longer cancellable. The underlying sets are
+deliberately not exported: every surface asks the predicate, so a new status
+cannot be learned by some call sites and not others.
+
+## Compatibility
+
+ESM only, built for bundler resolution (Vite, webpack, Rollup, esbuild). The
+emitted declarations use extensionless specifiers, which resolve under
+TypeScript's `bundler` module resolution and **not** under `node16`/`nodenext`.
+
+## License
+
+Apache-2.0. See [LICENSE](./LICENSE).

package/dist/bindings.d.ts

@@ -0,0 +1,8 @@
+import type { DashboardDefinition, SlotBinding } from './types';
+export declare function effectiveBindings(definition: DashboardDefinition, manifest?: Record<string, SlotBinding>): Record<string, SlotBinding>;
+export interface ParsedBindingManifest {
+    bindings: Record<string, SlotBinding>;
+    dropped: string[];
+}
+export declare function parseBindingManifest(raw: unknown): ParsedBindingManifest;
+export declare function stripDefaultBindings(def: DashboardDefinition): DashboardDefinition;

package/dist/candidates.d.ts

@@ -0,0 +1,3 @@
+import type { MemberResolver } from './context';
+import type { DashboardDefinition, EntityCandidateLister, SelectionCandidate, SlotBinding } from './types';
+export declare function resolveSlotCandidates(definition: DashboardDefinition, slot: string, bindings: Record<string, SlotBinding>, resolver: MemberResolver, lister: EntityCandidateLister): Promise<SelectionCandidate[]>;

package/dist/command-status.d.ts

@@ -0,0 +1,6 @@
+export declare const COMMAND_STATUSES: readonly ['QUEUED', 'HELD', 'SENT', 'PARKED', 'SUCCESSFUL', 'FAILED', 'TIMEOUT', 'EXPIRED', 'CANCELLED'];
+export type CommandStatus = (typeof COMMAND_STATUSES)[number];
+export declare const TERMINAL_COMMAND_STATUSES: ReadonlySet<string>;
+export declare const CANCELLABLE_COMMAND_STATUSES: ReadonlySet<string>;
+export declare function isTerminalCommandStatus(status: string): boolean;
+export declare function isCancellableCommandStatus(status: string): boolean;

package/dist/context.d.ts

@@ -0,0 +1,7 @@
+import type { DeviceResolver } from './hub';
+import type { DashboardDefinition, SelectionTarget, SlotBinding } from './types';
+export type MemberResolver = Pick<DeviceResolver, 'devicesForAnchor'>;
+export declare function hasScopedSlots(definition: DashboardDefinition): boolean;
+export declare function bindingsWithoutScopedSlots(definition: DashboardDefinition, map: Record<string, SlotBinding>): Record<string, SlotBinding>;
+export declare function applySelection(overlay: Record<string, SlotBinding>, target: SelectionTarget): Record<string, SlotBinding>;
+export declare function resolveContextBindings(definition: DashboardDefinition, base: Record<string, SlotBinding>, overlay: Record<string, SlotBinding>, resolver: MemberResolver): Promise<Record<string, SlotBinding>>;

package/dist/definition.d.ts

@@ -0,0 +1,13 @@
+import { type Breakpoints, type DashboardDefinition, type SlotBinding, type SlotDefinition, type WidgetBox, type WidgetLayout } from './types';
+export declare const BASE_BREAKPOINT = "base";
+export declare class DashboardDefinitionError extends Error {
+    constructor(message: string);
+}
+export declare function parseDashboardDefinition(raw: unknown): DashboardDefinition;
+export declare function canScopeSlot(slots: Record<string, SlotDefinition>, child: string, parentName: string): boolean;
+export declare function parseSlotBinding(raw: unknown): SlotBinding | undefined;
+export declare function serializeDefinition(def: DashboardDefinition): string;
+export declare function isDirty(a: DashboardDefinition, b: DashboardDefinition): boolean;
+export declare function resolveWidgetBox(layout: WidgetLayout, breakpoint: string): WidgetBox;
+export declare function activeBreakpoint(breakpoints: Breakpoints, viewportWidth: number): string;
+export declare function generateWidgetId(): string;

package/dist/editor-model.d.ts

@@ -0,0 +1,30 @@
+import type { CanvasGrid, CanvasSizing, DashboardDefinition, WidgetBox, WidgetInstance, WidgetType } from './types';
+export declare function baseBox(widget: WidgetInstance): WidgetBox;
+export declare function setWidgetBox(def: DashboardDefinition, id: string, box: WidgetBox): DashboardDefinition;
+export declare function deleteWidget(def: DashboardDefinition, id: string): DashboardDefinition;
+export declare function bringToFront(def: DashboardDefinition, id: string): DashboardDefinition;
+export declare function setTitle(def: DashboardDefinition, title: string): DashboardDefinition;
+export declare function setCanvasGrid(def: DashboardDefinition, patch: Partial<CanvasGrid>): DashboardDefinition;
+export declare function setCanvasSizing(def: DashboardDefinition, sizing: CanvasSizing): DashboardDefinition;
+export declare function updateWidget(def: DashboardDefinition, id: string, next: WidgetInstance): DashboardDefinition;
+export declare function addWidget(def: DashboardDefinition, type: WidgetType): {
+    definition: DashboardDefinition;
+    id: string;
+};
+export interface PixelRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface GridGeometry {
+    colWidth: number;
+    colGap: number;
+    rowHeight: number;
+    rowGap: number;
+}
+export declare function gridBoxToPx(box: WidgetBox, geom: GridGeometry): PixelRect;
+export declare function pxToGridBox(px: PixelRect, geom: GridGeometry, z: number, offset?: {
+    x: number;
+    y: number;
+}, columns?: number): WidgetBox;

package/dist/entity-lister.d.ts

@@ -0,0 +1,2 @@
+import type { EntityCandidateLister } from './types';
+export declare function createEntityLister(): EntityCandidateLister;

package/dist/history.d.ts

@@ -0,0 +1,8 @@
+import type { MeasurementSample, SlotBinding, WidgetInstance } from './types';
+export interface HistoryWindow {
+    startTime: string;
+    endTime: string;
+    intervalSeconds: number;
+}
+export declare function defaultHistoryWindow(): HistoryWindow;
+export declare function fetchWidgetHistory(widget: WidgetInstance, window: HistoryWindow, bindings?: Record<string, SlotBinding>): Promise<MeasurementSample[]>;

package/dist/hub.d.ts

@@ -0,0 +1,115 @@
+import type { AlarmRow, AnchorTarget, CommandRow, DatasourceSelector, LocationSample, MeasurementSample, SlotBinding } from './types';
+export interface DeviceResolver {
+    devicesForAnchor(anchor: AnchorTarget): Promise<string[]>;
+    deviceExists(deviceToken: string): Promise<boolean>;
+}
+export interface WidgetStreamSink {
+    next: (sample: MeasurementSample) => void;
+    error?: (err: unknown) => void;
+}
+export interface AlarmSubscription {
+    datasource?: DatasourceSelector;
+    state?: string;
+    severity?: string;
+    acknowledged?: boolean;
+    pageSize: number;
+}
+export interface AlarmSnapshot {
+    alarms: AlarmRow[];
+    total: number;
+}
+export interface AlarmStreamSink {
+    next: (snapshot: AlarmSnapshot) => void;
+    error?: (err: unknown) => void;
+}
+export interface CommandSubscription {
+    datasource?: DatasourceSelector;
+    pageSize: number;
+}
+export interface CommandSnapshot {
+    deviceToken: string | null;
+    commands: CommandRow[];
+    total: number;
+}
+export interface CommandStreamSink {
+    next: (snapshot: CommandSnapshot) => void;
+    error?: (err: unknown) => void;
+}
+export type CommandDispatch = {
+    status: 'sent';
+    token: string;
+} | {
+    status: 'rejected';
+    code: string;
+    reason: string;
+};
+export interface LocationSubscription {
+    datasource?: DatasourceSelector;
+}
+export type LocationSnapshot = {
+    kind: 'positions';
+    deviceTokens: string[];
+    locations: LocationSample[];
+} | {
+    kind: 'forbidden';
+};
+export interface LocationStreamSink {
+    next: (snapshot: LocationSnapshot) => void;
+    error?: (err: unknown) => void;
+}
+export interface WidgetActions {
+    acknowledgeAlarm(alarmToken: string): Promise<void>;
+    clearAlarm(alarmToken: string): Promise<void>;
+    sendCommand?(deviceToken: string, name: string, payload?: string): Promise<CommandDispatch>;
+    can(authority: string): boolean;
+}
+export interface DashboardHubConfig {
+    resolver: DeviceResolver;
+    bindings?: Record<string, SlotBinding>;
+    authorities?: string[];
+}
+export interface WidgetDataSource {
+    subscribeWidget(datasource: DatasourceSelector, sink: WidgetStreamSink): () => void;
+    subscribeAlarms(subscription: AlarmSubscription, sink: AlarmStreamSink): () => void;
+    subscribeCommands(subscription: CommandSubscription, sink: CommandStreamSink): () => void;
+    subscribeLocations(subscription: LocationSubscription, sink: LocationStreamSink): () => void;
+    isDatasourceAvailable(datasource: DatasourceSelector | undefined): Promise<boolean>;
+}
+export declare class DashboardHub implements WidgetDataSource, WidgetActions {
+    private readonly resolver;
+    private readonly authorities;
+    private readonly alarmReconcilers;
+    private readonly commandReconcilers;
+    private readonly streams;
+    private readonly alarmDisposers;
+    private readonly commandDisposers;
+    private readonly locationDisposers;
+    private bindings;
+    constructor(config: DashboardHubConfig);
+    setBindings(bindings: Record<string, SlotBinding>): void;
+    subscribeWidget(datasource: DatasourceSelector, sink: WidgetStreamSink): () => void;
+    subscribeAlarms(subscription: AlarmSubscription, sink: AlarmStreamSink): () => void;
+    private resolveAlarmScope;
+    private queryAlarms;
+    subscribeCommands(subscription: CommandSubscription, sink: CommandStreamSink): () => void;
+    private resolveCommandScope;
+    private queryCommands;
+    subscribeLocations(subscription: LocationSubscription, sink: LocationStreamSink): () => void;
+    private resolveLocationScope;
+    private queryLocations;
+    can(authority: string): boolean;
+    acknowledgeAlarm(alarmToken: string): Promise<void>;
+    clearAlarm(alarmToken: string): Promise<void>;
+    sendCommand(deviceToken: string, name: string, payload?: string): Promise<CommandDispatch>;
+    private reconcileAlarms;
+    private reconcileCommands;
+    disposeAll(): void;
+    get openStreamCount(): number;
+    isDatasourceAvailable(datasource: DatasourceSelector | undefined): Promise<boolean>;
+    private availabilityToken;
+    private resolveDevices;
+    private resolveBinding;
+    private attach;
+    private ensureStream;
+    private fanout;
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export type { DashboardDefinition, Canvas, CanvasBackground, CanvasGrid, CanvasSizing, Breakpoints, WidgetInstance, WidgetType, WidgetLayout, WidgetBox, DatasourceSelector, DeviceSelector, AnchorSelector, AnchorTarget, AnchorAggregation, DevicesSelector, RelatedTraversalSelector, SlotSelector, SlotDefinition, SlotScope, SlotBinding, SelectionTarget, SelectionCandidate, EntityCandidateLister, EntityListKind, MeasurementSample, LocationSample, LocationSeries, LocationSelection, AlarmRow, CommandRow, CommandParameter, CommandParamDataType, } from './types';
+export { COMMAND_STATUSES, isTerminalCommandStatus, isCancellableCommandStatus, type CommandStatus, } from './command-status';
+export { effectiveBindings, parseBindingManifest, stripDefaultBindings, type ParsedBindingManifest, } from './bindings';
+export { resolveContextBindings, hasScopedSlots, applySelection, bindingsWithoutScopedSlots, type MemberResolver, } from './context';
+export { migrateToSlots, bindWidgetSlot, clearWidgetDatasource, pruneSlots, widgetBinding, widgetSlotName, sameBinding, resolveConcrete, setSlotScope, anchorSlotNames, type ConcreteSelector, } from './slots';
+export { resolveSlotCandidates } from './candidates';
+export { createEntityLister } from './entity-lister';
+export { WIDGET_TYPES } from './types';
+export { DashboardHub, type DashboardHubConfig, type DeviceResolver, type WidgetStreamSink, type WidgetDataSource, type AlarmSubscription, type AlarmSnapshot, type AlarmStreamSink, type CommandSubscription, type CommandSnapshot, type CommandStreamSink, type CommandDispatch, type LocationSubscription, type LocationSnapshot, type LocationStreamSink, type WidgetActions, } from './hub';
+export { SyntheticDataSource, SYNTHETIC_GENERATORS, type SyntheticGenerator, type SyntheticDataSourceConfig, } from './synthetic';
+export { parseDashboardDefinition, parseSlotBinding, serializeDefinition, isDirty, resolveWidgetBox, activeBreakpoint, generateWidgetId, canScopeSlot, DashboardDefinitionError, BASE_BREAKPOINT, } from './definition';
+export { baseBox, setWidgetBox, deleteWidget, bringToFront, setTitle, setCanvasGrid, setCanvasSizing, updateWidget, addWidget, gridBoxToPx, pxToGridBox, type PixelRect, type GridGeometry, } from './editor-model';
+export { createDeviceResolver } from './resolver';
+export { defaultHistoryWindow, fetchWidgetHistory, type HistoryWindow } from './history';