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

package/dist/src/workspace/graphics/inspector/multi.d.ts

@@ -0,0 +1,10 @@
+import { type GraphicsDocument } from "@overvis/hmi-shared/graphics";
+/**
+ * Several selected objects: the settings they have in common, each showing a mixed state when
+ * their values differ. A change applies to every selected object.
+ */
+export declare function GraphicsMultiInspector({ document, selection, onChange, }: {
+    document: GraphicsDocument;
+    selection: readonly string[];
+    onChange: (document: GraphicsDocument) => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/inspector/panel.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from "react";
+import type { GraphicsDocument } from "@overvis/hmi-shared/graphics";
+/** A field a save error points at; `nonce` repeats the request for the same field. */
+export interface GraphicsFieldFocus {
+    field: string;
+    nonce: number;
+}
+/**
+ * The inspector pane. Its sections keep their open state across selections, and `focus` shows
+ * and focuses a field, for example the one a save error names.
+ */
+export declare function GraphicsInspectorPane({ focus, className, children, }: {
+    focus: GraphicsFieldFocus | null;
+    className?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Properties of the selection. Typing in a field is one undo step: `onChange` receives
+ * `checkpoint: false` for the keystrokes after the first.
+ */
+export declare function GraphicsInspector(props: {
+    workspaceId: string;
+    document: GraphicsDocument;
+    selection: readonly string[];
+    onChange: (document: GraphicsDocument, checkpoint?: boolean) => void;
+    onSelect: (ids: string[]) => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/inspector/ports.d.ts

@@ -0,0 +1,2 @@
+/** Readable name of a connection point: built-in IDs are translated, others spelled out. */
+export declare function graphicsPortLabel(port: string): string;

package/dist/src/workspace/graphics/inspector/section.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+/** Sections a user opens or closes stay that way while other objects are selected. */
+export declare function GraphicsSectionsProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Open a section, for example to show a field a save error points at. */
+export declare function useGraphicsSectionOpener(): (id: string) => void;
+/** A collapsible inspector section; `id` keeps its state across selections. */
+export declare function GraphicsInspectorSection({ id, title, defaultOpen, children, }: {
+    id: string;
+    title: string;
+    defaultOpen: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/inspector/slots.d.ts

@@ -0,0 +1,7 @@
+import { type GraphicsDocument } from "@overvis/hmi-shared/graphics";
+/** The drawing's shared slots: each one's name, parameter and how many bindings use it. */
+export declare function GraphicsSlotList(props: {
+    workspaceId: string;
+    document: GraphicsDocument;
+    onChange: (document: GraphicsDocument, checkpoint?: boolean) => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/inspector/symbol.d.ts

@@ -0,0 +1,11 @@
+import { type GraphicsElement } from "@overvis/hmi-shared/graphics";
+import { type GraphicsItemProps } from "./item.js";
+type SymbolElement = Extract<GraphicsElement, {
+    kind: "symbol";
+}>;
+/**
+ * A symbol, in the order people configure it: name and type, key properties and their bindings,
+ * readings and states, then placement, appearance and host bindings, and its actions.
+ */
+export declare function GraphicsSymbolInspector(props: GraphicsItemProps<SymbolElement>): import("react").JSX.Element;
+export {};

package/dist/src/workspace/graphics/line-geometry.d.ts

@@ -0,0 +1,26 @@
+import { type GraphicsAppearance, type GraphicsConnector, type GraphicsDocument, type GraphicsEndpoint, type GraphicsPoint } from "@overvis/hmi-shared/graphics";
+import type { GraphicsSymbolDefinition } from "./symbols/definition.js";
+export declare function graphicsEndpointPoint(end: GraphicsEndpoint, document: GraphicsDocument, symbols: ReadonlyMap<string, GraphicsSymbolDefinition>): GraphicsPoint;
+export declare function graphicsLinePoints(line: GraphicsConnector, document: GraphicsDocument, symbols: ReadonlyMap<string, GraphicsSymbolDefinition>): GraphicsPoint[];
+export declare function projectGraphicsPoint(point: GraphicsPoint, from: GraphicsPoint, to: GraphicsPoint): GraphicsPoint;
+/**
+ * Only dropping an endpoint makes a connection. Crossing paths never changes topology. Without
+ * `snap` (Alt held), an endpoint or junction that attaches to no port keeps its exact point.
+ */
+export declare function attachGraphicsEndpoint(document: GraphicsDocument, point: GraphicsPoint, symbols: ReadonlyMap<string, GraphicsSymbolDefinition>, tolerance: number, excludeId?: string, snap?: boolean): {
+    document: GraphicsDocument;
+    endpoint: GraphicsEndpoint;
+    /** The line the endpoint split with a new junction. */
+    line?: GraphicsConnector;
+    /** Where the endpoint lands. */
+    point: GraphicsPoint;
+};
+/**
+ * The stroke of a new line: that of the line it splits, or of a line already on one of its
+ * ports. Otherwise the drawing's most recent line of the same kind, such as the last pipe for a
+ * process port; a line without symbol ports takes the most recent line's stroke.
+ */
+export declare function graphicsNewLineAppearance(document: GraphicsDocument, ends: readonly {
+    endpoint: GraphicsEndpoint;
+    line?: GraphicsConnector;
+}[], symbols: ReadonlyMap<string, GraphicsSymbolDefinition>): GraphicsAppearance;

package/dist/src/workspace/graphics/lines.d.ts

@@ -0,0 +1,14 @@
+import type { CanvasProps } from "./canvas.js";
+import type { GraphicsQuality } from "./binding-value.js";
+export declare function GraphicsLines({ canvas, layers, qualities, }: {
+    canvas: CanvasProps;
+    layers: ReadonlyMap<string, number>;
+    qualities: ReadonlyMap<string, GraphicsQuality>;
+}): import("react").JSX.Element;
+/**
+ * The Line tool: press on the drawing and drag to draw a line. It stays on for the next line
+ * until Escape or the tool's button turns it off; Escape during a drag drops that line only.
+ */
+export declare function GraphicsLineDrawing({ canvas }: {
+    canvas: CanvasProps;
+}): import("react").JSX.Element | null;

package/dist/src/workspace/graphics/node-memo.d.ts

@@ -0,0 +1,3 @@
+import type { NodeProps } from "@xyflow/react";
+import type { GraphicNode } from "./canvas.js";
+export declare function graphicsNodeUnchanged(previous: NodeProps<GraphicNode>, next: NodeProps<GraphicNode>): boolean;

package/dist/src/workspace/graphics/node.d.ts

@@ -0,0 +1,3 @@
+import { type NodeProps } from "@xyflow/react";
+import type { GraphicNode } from "./canvas.js";
+export declare function GraphicsNode({ data, selected }: NodeProps<GraphicNode>): import("react").JSX.Element;

package/dist/src/workspace/graphics/placement.d.ts

@@ -0,0 +1,23 @@
+import { type GraphicsElement } from "@overvis/hmi-shared/graphics";
+import { type GraphicsSymbolDefinition } from "./symbols/definition.js";
+/** A symbol waiting to be placed: each click or tap adds one copy. */
+export interface GraphicsPlacement {
+    symbol: GraphicsSymbolDefinition;
+    properties: Readonly<Record<string, string | number | boolean>>;
+    /** Keep placing copies until Done or Escape; otherwise stop after the first. */
+    multiple: boolean;
+}
+/**
+ * Covers the canvas while a symbol is placed. A grid-snapped preview follows the pointer; clicking
+ * or tapping places a copy. Arrow keys move the preview by one grid step and Enter places it; R,
+ * Shift+R, Shift+H and Shift+V turn and mirror it. The wheel, a pinch and a middle-button drag
+ * still zoom and pan the drawing. Escape, Done or Cancel stops without creating anything more.
+ */
+export declare function GraphicsPlacementLayer({ placement, grid, onPlace, onEnd, }: {
+    placement: GraphicsPlacement;
+    grid: number;
+    onPlace: (element: Extract<GraphicsElement, {
+        kind: "symbol";
+    }>) => void;
+    onEnd: () => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/quality-indicator.d.ts

@@ -0,0 +1,6 @@
+export declare function QualityIndicator({ x, y, quality, onInspect, }: {
+    x: number;
+    y: number;
+    quality: "stale" | "unknown";
+    onInspect: () => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/resize-handles.d.ts

@@ -0,0 +1,8 @@
+import { type GraphicsDocument, type GraphicsElement } from "@overvis/hmi-shared/graphics";
+/** Selection controls sit above the drawing without changing the artwork's stacking order. */
+export declare function GraphicsResizeHandles({ document, elements, layer, onBeginEdit, }: {
+    document: GraphicsDocument;
+    elements: readonly GraphicsElement[];
+    layer: number;
+    onBeginEdit: () => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/source-picker.d.ts

@@ -0,0 +1,35 @@
+import { type ReactNode } from "react";
+import { type GraphicsSymbolBinding, type GraphicsDocument, type GraphicsSource } from "@overvis/hmi-shared/graphics";
+import type { ParameterWithReadings } from "@overvis/hmi-shared/parameter";
+type ValueTypeName = ParameterWithReadings["valueType"]["name"];
+/** Parameter types a binding of this kind can read; the picker lists them first. */
+export declare function graphicsBindingValueTypes(kind: GraphicsSymbolBinding["kind"]): readonly ValueTypeName[] | undefined;
+export declare function GraphicsParameterPicker({ workspaceId, value, onChange, label, labelHidden, valueTypes, description, describeSelected, allowEmpty, }: {
+    workspaceId: string;
+    value: string | null;
+    onChange: (value: string | null) => void;
+    label?: string | undefined;
+    labelHidden?: boolean;
+    valueTypes?: readonly ValueTypeName[] | undefined;
+    description?: ReactNode;
+    /** Say below the field when no parameter is assigned. */
+    describeSelected?: boolean;
+    /** Whether the parameter can be cleared; a binding's own parameter cannot be left empty. */
+    allowEmpty?: boolean;
+}): import("react").JSX.Element;
+/**
+ * The parameter a binding or action reads. The parameter comes from a shared slot, which other
+ * bindings may use too, or is assigned to this binding only.
+ */
+export declare function SourcePicker({ workspaceId, source, document, valueTypes, label, labelHidden, slotName, onChange, }: {
+    workspaceId: string;
+    source: GraphicsSource;
+    document: GraphicsDocument;
+    valueTypes?: readonly ValueTypeName[] | undefined;
+    label?: string;
+    labelHidden?: boolean;
+    /** Name of a slot created for this binding alone. */
+    slotName?: string;
+    onChange: (source: GraphicsSource, document?: GraphicsDocument) => void;
+}): import("react").JSX.Element;
+export {};

package/dist/src/workspace/graphics/symbol-issues.d.ts

@@ -0,0 +1,26 @@
+import { type GraphicsDocument, type GraphicsSymbolIssue } from "@overvis/hmi-shared/graphics";
+import type { GraphicsSymbolDefinition } from "./symbols/definition.js";
+type Symbols = ReadonlyMap<string, GraphicsSymbolDefinition>;
+/** What a save problem points at: the object to select and the field to focus. */
+export interface GraphicsIssueTarget {
+    selection: string[];
+    /** A `data-graphics-field` value of the inspector, or `null` for the object as a whole. */
+    field: string | null;
+}
+/** One line per distinct problem, naming the object by its name or symbol. */
+export declare function graphicsIssueLines(issues: readonly GraphicsSymbolIssue[], document: GraphicsDocument, symbols: Symbols): string[];
+/**
+ * Symbol problems that rejected a save (`details.issues` of `graphics_invalid_document`), as
+ * text naming each object, or `null` for the standard API error text.
+ */
+export declare function graphicsSaveIssuesText(error: unknown, document: GraphicsDocument, symbols: Symbols): string | null;
+/** The object and field of the first symbol problem that rejected a save. */
+export declare function graphicsSaveIssueTarget(error: unknown, document: GraphicsDocument): GraphicsIssueTarget | null;
+/**
+ * Where a drawing validation issue lies, from its path such as `["elements", 2, "appearance",
+ * "opacity"]`, and a message naming the object and field.
+ */
+export declare function graphicsDocumentIssueTarget(document: GraphicsDocument, path: readonly unknown[], symbols: Symbols): GraphicsIssueTarget & {
+    message: string;
+};
+export {};

package/dist/src/workspace/graphics/symbols/agriculture/fertigation.d.ts

@@ -0,0 +1 @@
+export declare const fertigationUnit: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/agriculture/index.d.ts

@@ -0,0 +1,2 @@
+/** Irrigation: zones, sprinklers and drip emitters, fertigation and soil sensors. */
+export declare const agricultureGraphicsSymbols: import("../definition.js").GraphicsSymbolDefinition[];

package/dist/src/workspace/graphics/symbols/agriculture/soil-sensor.d.ts

@@ -0,0 +1 @@
+export declare const soilSensor: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/agriculture/soil.d.ts

@@ -0,0 +1,9 @@
+/** Soil darkens from dry to wet with the moisture reading, 0 to 100. */
+export declare function soilColor(moisture: number): string;
+/** Soil whose moisture is unavailable; it shows no wetness at all. */
+export declare const unknownSoil = "#eef0f2";
+/** A water drop marking a moisture reading. */
+export declare function MoistureDrop({ x, y }: {
+    x: number;
+    y: number;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/symbols/agriculture/sprinkler.d.ts

@@ -0,0 +1 @@
+export declare const sprinkler: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/agriculture/zone.d.ts

@@ -0,0 +1 @@
+export declare const irrigationZone: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/bindings.d.ts

@@ -0,0 +1,34 @@
+import { type AppLocale } from "@overvis/hmi-shared";
+import { type GraphicsDocument, type GraphicsElement } from "@overvis/hmi-shared/graphics";
+import type { Parameter } from "@overvis/hmi-shared/parameter";
+import type { ParameterValueState } from "../../parameters/live/model.js";
+import { type GraphicsQuality } from "../binding-value.js";
+import type { GraphicsSymbolDefinition } from "./definition.js";
+import type { GraphicsSymbolPropertyState } from "./viewport.js";
+/** Parameter setup the drawing needs besides live values. */
+export type GraphicsParameterSetup = ReadonlyMap<string, Pick<Parameter, "units">>;
+/** Domain properties and host properties share value semantics, but have separate destinations. */
+export declare function resolveGraphicsSymbolProperties(element: Extract<GraphicsElement, {
+    kind: "symbol";
+}>, document: GraphicsDocument, states: ReadonlyMap<string, ParameterValueState>, parameters: GraphicsParameterSetup, locale: AppLocale, definition?: GraphicsSymbolDefinition): {
+    properties: {
+        [x: string]: string | number | boolean | Record<string, string>;
+    };
+    bindings: Record<string, GraphicsSymbolPropertyState>;
+    quality: GraphicsQuality;
+};
+/**
+ * While editing there are no live values: bound numeric readings show as unavailable ("—") with
+ * their parameter's units, instead of the property's default, such as "0 bar".
+ */
+export declare function graphicsEditingSymbolBindings(document: GraphicsDocument, parameters: GraphicsParameterSetup | undefined, locale: AppLocale, definitions: ReadonlyMap<string, GraphicsSymbolDefinition>): Map<string, Readonly<Record<string, GraphicsSymbolPropertyState>>>;
+/**
+ * Fit resolved values to the symbol's schema: an unknown choice becomes `unknown` where the
+ * symbol offers it, numbers stay within declared bounds, and a reading's unit property shows the
+ * parameter's units unless the placement sets it. A bound choice outside the schema is reported
+ * as unknown, so the symbol never draws its fallback as live feedback.
+ */
+export declare function graphicsSymbolRenderProperties(definition: GraphicsSymbolDefinition, properties: Readonly<Record<string, unknown>>, bindings: Readonly<Record<string, GraphicsSymbolPropertyState>>): {
+    properties: Record<string, unknown>;
+    bindings: Readonly<Record<string, GraphicsSymbolPropertyState>>;
+};

package/dist/src/workspace/graphics/symbols/browser.d.ts

@@ -0,0 +1,28 @@
+import { type ReactNode } from "react";
+import { type GraphicsSymbolFilters } from "./catalog.js";
+import { type GraphicsSymbolDefinition } from "./definition.js";
+/** Browser state kept by the editor, so search, filters and selection survive reopening. */
+export interface GraphicsSymbolBrowserState {
+    filters: GraphicsSymbolFilters;
+    symbolId: string | null;
+    variantId: string | null;
+    multiple: boolean;
+}
+export declare const initialGraphicsSymbolBrowserState: GraphicsSymbolBrowserState;
+export interface GraphicsSymbolInsertion {
+    symbol: GraphicsSymbolDefinition;
+    properties: Readonly<Record<string, string | number | boolean>>;
+    multiple: boolean;
+}
+/**
+ * The symbol library: categories and quick access on the left, search and filters above the
+ * thumbnails, and details with variants for the selected symbol. It fills narrow screens.
+ */
+export declare function GraphicsSymbolBrowser({ workspaceId, state, onStateChange, onInsert, children, }: {
+    workspaceId: string;
+    state: GraphicsSymbolBrowserState;
+    onStateChange: (state: GraphicsSymbolBrowserState) => void;
+    onInsert: (insertion: GraphicsSymbolInsertion) => void;
+    /** Extra content under the results when nothing narrows them, such as workspace images. */
+    children?: ReactNode;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/symbols/builtins.d.ts

@@ -0,0 +1,2 @@
+import type { GraphicsSymbolDefinition } from "./definition.js";
+export declare const builtinGraphicsSymbols: GraphicsSymbolDefinition[];

package/dist/src/workspace/graphics/symbols/button.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./definition.js").GraphicsSymbolDefinition;
+export default _default;

package/dist/src/workspace/graphics/symbols/catalog.d.ts

@@ -0,0 +1,41 @@
+import { type GraphicsIndustry } from "@overvis/hmi-shared/graphics";
+import type { GraphicsSymbolDefinition } from "./definition.js";
+export declare function graphicsSymbolCategories(): {
+    id: string;
+    name: string;
+}[];
+export declare function graphicsIndustryName(industry: GraphicsIndustry): string;
+/** Search terms from one translated, comma-separated list. */
+export declare function graphicsSymbolKeywords(terms: string): string[];
+/**
+ * How well a symbol matches a search, or null when it does not. Every search word must start a
+ * word of the name, identifier, description, family, variants or keywords, directly or as a
+ * plural's stem; words joined by punctuation must appear as written. Names outrank keywords and keywords outrank descriptions; whole words outrank
+ * word starts. Industries have their own filter; matching their names would list, say, every
+ * motor for "pump".
+ */
+export declare function graphicsSymbolSearchScore(symbol: GraphicsSymbolDefinition, query: string): number | null;
+/** Whether a search word starts one of the given terms, such as things drawn with the Line tool. */
+export declare function graphicsSearchMentions(query: string, terms: readonly string[]): boolean;
+export type GraphicsSymbolSource = "all" | "builtin" | "workspace";
+/** Library navigation: a category or a quick-access list, then secondary filters. */
+export interface GraphicsSymbolFilters {
+    search: string;
+    /** `all`, `favorites`, `recent`, an equipment category or `uncategorized`. */
+    category: string;
+    industry: GraphicsIndustry | "all";
+    source: GraphicsSymbolSource;
+}
+export declare const defaultGraphicsSymbolFilters: GraphicsSymbolFilters;
+export declare function graphicsSymbolCategory(symbol: GraphicsSymbolDefinition): string;
+/** Industries used by at least one available symbol, in the controlled order. */
+export declare function graphicsSymbolIndustries(symbols: Iterable<GraphicsSymbolDefinition>): GraphicsIndustry[];
+/**
+ * Symbols matching every filter. Better search matches come first; otherwise members of one
+ * family stay next to each other. Recent symbols keep the order they were used in.
+ */
+export declare function filterGraphicsSymbols(symbols: Iterable<GraphicsSymbolDefinition>, filters: GraphicsSymbolFilters, context: {
+    builtins: ReadonlySet<string>;
+    favorites: ReadonlySet<string>;
+    recents: readonly string[];
+}): GraphicsSymbolDefinition[];

package/dist/src/workspace/graphics/symbols/compressed-air/compressor.d.ts

@@ -0,0 +1 @@
+export declare const airCompressor: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/compressed-air/drain.d.ts

@@ -0,0 +1,15 @@
+import type { OperatingState } from "../hvac/index.js";
+/**
+ * State of equipment without operating feedback, from its alarm flags: a known fault or warning
+ * wins, an unavailable flag makes the state Unknown, and otherwise it is normal.
+ */
+export declare function useAlarmState(fault: readonly [property: string, value: boolean], warnings: readonly (readonly [property: string, value: boolean])[]): {
+    state: OperatingState;
+    warning: string | undefined;
+};
+/** A condensate drain valve below `x, y`; drops fall while it discharges. */
+export declare function Drain({ x, y, active }: {
+    x: number;
+    y: number;
+    active: boolean;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/symbols/compressed-air/index.d.ts

@@ -0,0 +1 @@
+export declare const compressedAirGraphicsSymbols: import("../definition.js").GraphicsSymbolDefinition[];

package/dist/src/workspace/graphics/symbols/compressed-air/receiver.d.ts

@@ -0,0 +1 @@
+export declare const airReceiver: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/compressed-air/treatment.d.ts

@@ -0,0 +1,2 @@
+export declare const airDryer: import("../definition.js").GraphicsSymbolDefinition;
+export declare const lineFilter: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/definition.d.ts

@@ -0,0 +1,115 @@
+import { type GraphicsSymbolViewport } from "./viewport.js";
+import { type ComponentType, type ReactNode } from "react";
+import Type, { type Static, type TObject } from "typebox";
+import { type GraphicsElement, type GraphicsSymbolGeometry } from "@overvis/hmi-shared/graphics";
+export declare const graphicsSymbolMetadataType: TObject<{
+    id: Type.TString;
+    name: Type.TString;
+    width: Type.TNumber;
+    height: Type.TNumber;
+    stretch: Type.TBoolean;
+    catalog: Type.TOptional<TObject<{
+        category: Type.TEnum<["pumps-motors", "valves", "filters-separators", "tanks-vessels", "instruments", "electrical", "heating-cooling", "air-handling", "controls-indicators", "material-handling", "machines", "buildings-storage"]>;
+        family: Type.TOptional<Type.TString>;
+        industries: Type.TArray<Type.TEnum<["water", "wastewater", "pumping", "energy", "power", "heating", "hvac", "temperature", "manufacturing", "warehouses", "waste-recycling", "quarries", "compressed-air", "agriculture", "food-beverage", "fuel-gas", "controls"]>>;
+        description: Type.TString;
+        keywords: Type.TArray<Type.TString>;
+        variants: Type.TOptional<Type.TArray<TObject<{
+            id: Type.TString;
+            name: Type.TString;
+            properties: Type.TRecord<"^.*$", Type.TUnion<[Type.TNumber, Type.TString, Type.TBoolean]>>;
+        }>>>;
+        essential: Type.TOptional<Type.TArray<Type.TString>>;
+        units: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+        examples: Type.TArray<TObject<{
+            id: Type.TString;
+            name: Type.TString;
+            properties: Type.TRecord<"^.*$", Type.TUnion<[Type.TNumber, Type.TString, Type.TBoolean]>>;
+        }>>;
+        grid: Type.TOptional<TObject<{
+            base: Type.TLiteral<10>;
+            minScale: Type.TOptional<Type.TNumber>;
+            maxScale: Type.TOptional<Type.TNumber>;
+            minWidth: Type.TOptional<Type.TNumber>;
+            minHeight: Type.TOptional<Type.TNumber>;
+            maxWidth: Type.TOptional<Type.TNumber>;
+            maxHeight: Type.TOptional<Type.TNumber>;
+        }>>;
+    }>>;
+    actions: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+    ports: Type.TArray<TObject<{
+        id: Type.TString;
+        x: Type.TNumber;
+        y: Type.TNumber;
+        anchorX: Type.TOptional<Type.TUnion<[Type.TLiteral<"start">, Type.TLiteral<"center">, Type.TLiteral<"end">, Type.TLiteral<"scale">]>>;
+        anchorY: Type.TOptional<Type.TUnion<[Type.TLiteral<"start">, Type.TLiteral<"center">, Type.TLiteral<"end">, Type.TLiteral<"scale">]>>;
+        role: Type.TOptional<Type.TEnum<["process", "air", "electrical", "signal", "material"]>>;
+        direction: Type.TOptional<Type.TEnum<["in", "out", "both"]>>;
+    }>>;
+    /**
+     * The equipment body inside the placed box, as fractions of its width and height, leaving out
+     * pipe stubs and margins; it must lie inside the box. The data-quality badge sits at the body's
+     * top-right corner, so artwork keeps about 24 units there free. Defaults to the whole box.
+     */
+    body: Type.TOptional<TObject<{
+        x: Type.TNumber;
+        y: Type.TNumber;
+        width: Type.TNumber;
+        height: Type.TNumber;
+    }>>;
+}>;
+export type GraphicsSymbolMetadata = Static<typeof graphicsSymbolMetadataType>;
+export type GraphicsSymbolDefinition = Omit<GraphicsSymbolMetadata, "catalog"> & {
+    catalog?: GraphicsSymbolMetadata["catalog"];
+    properties: TObject;
+    render: (properties: unknown, viewport?: GraphicsSymbolViewport) => ReactNode;
+    validate: (properties: unknown) => boolean;
+};
+/** Parse author-supplied property schemas at the definition/module boundary. */
+export declare function isGraphicsSymbolProperties(properties: unknown): properties is TObject;
+/**
+ * Catalog variants selected by one choice property, named by the choices' titles. For example,
+ * a valve's `body` choices become its ball, gate, and butterfly variants.
+ */
+export declare function graphicsSymbolVariants(properties: TObject, property: string): NonNullable<NonNullable<GraphicsSymbolMetadata["catalog"]>["variants"]>;
+/** A symbol is a React component. It owns the layout and state of its contents. */
+export declare function defineGraphicsSymbol<T extends TObject>(definition: Omit<GraphicsSymbolMetadata, "name" | "actions" | "catalog"> & {
+    name: () => string;
+    actions?: () => NonNullable<GraphicsSymbolMetadata["actions"]>;
+    catalog?: () => NonNullable<GraphicsSymbolMetadata["catalog"]>;
+    properties: () => T;
+    Component: ComponentType<Static<T>>;
+}): GraphicsSymbolDefinition;
+export declare function createGraphicsSymbolElement(definition: GraphicsSymbolDefinition, id: string, position: {
+    x: number;
+    y: number;
+}): Extract<GraphicsElement, {
+    kind: "symbol";
+}>;
+/** The parts of a definition that decide where its ports land. */
+export declare function graphicsSymbolGeometry(definition: Pick<GraphicsSymbolDefinition, "width" | "height" | "stretch" | "ports" | "catalog">): GraphicsSymbolGeometry;
+/** Workspace validators are executable author code and may throw. */
+/** Whether a property holds display text, which a placement may store once per locale. */
+export declare function isGraphicsTextProperty(definition: GraphicsSymbolDefinition, property: string): boolean;
+/** Check one stored value; a display-text property may hold a valid text per locale instead. */
+export declare function validateGraphicsSymbolProperty(definition: GraphicsSymbolDefinition, property: string, value: unknown): boolean;
+export declare function validateGraphicsSymbolProperties(definition: GraphicsSymbolDefinition, properties: unknown): boolean;
+/**
+ * Where the data-quality badge goes in the placed box: the artwork's own top-right corner of the
+ * symbol's body, carried through mirroring and rotation with the artwork. Symbols keep that corner
+ * free in their own coordinates, so the badge never lands on a status mark however the placement is
+ * turned. It sits 6 units inside the corner, so it stays on the equipment.
+ */
+export declare function graphicsSymbolBadgePoint(definition: Pick<GraphicsSymbolMetadata, "body"> | undefined, element: {
+    width: number;
+    height: number;
+    rotation: number;
+    mirrorX?: boolean;
+    mirrorY?: boolean;
+}, box: {
+    width: number;
+    height: number;
+}): {
+    x: number;
+    y: number;
+};

package/dist/src/workspace/graphics/symbols/electrical/breaker.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../definition.js").GraphicsSymbolDefinition;
+export default _default;

package/dist/src/workspace/graphics/symbols/electrical/compensation.d.ts

@@ -0,0 +1 @@
+export declare const capacitorBank: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/electrical/index.d.ts

@@ -0,0 +1,5 @@
+export declare const powerGraphicsSymbols: import("../definition.js").GraphicsSymbolDefinition[];
+export { default as supply } from "./supply.js";
+export { default as breaker } from "./breaker.js";
+export { lamp, motor, refrigeration } from "./loads.js";
+export { PowerCaptions, PowerFrame, PowerIndicator, PowerReading, PowerStatus, powerColor, powerStateLine, powerStatusText, powerTagLine, usePowerReadingLine, } from "./presentation.js";

package/dist/src/workspace/graphics/symbols/electrical/loads.d.ts

@@ -0,0 +1,3 @@
+export declare const lamp: import("../definition.js").GraphicsSymbolDefinition;
+export declare const motor: import("../definition.js").GraphicsSymbolDefinition;
+export declare const refrigeration: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/electrical/machines.d.ts

@@ -0,0 +1,3 @@
+export declare const transformer: import("../definition.js").GraphicsSymbolDefinition;
+export declare const generator: import("../definition.js").GraphicsSymbolDefinition;
+export declare const variableFrequencyDrive: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/electrical/metering.d.ts

@@ -0,0 +1,8 @@
+export declare const electricityMeter: import("../definition.js").GraphicsSymbolDefinition;
+/**
+ * The meter's readings on a short face: energy, power and, when supplied, export energy. It keeps
+ * single-line diagrams of many feeders compact; lost communication or a fault shows on the status
+ * dot and greys the readings out.
+ */
+export declare const electricityMeterCompact: import("../definition.js").GraphicsSymbolDefinition;
+export declare const threePhasePanel: import("../definition.js").GraphicsSymbolDefinition;