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

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

@@ -0,0 +1,46 @@
+import type { TSchema } from "typebox";
+import { type GraphicsDocument, type GraphicsElement } from "@overvis/hmi-shared/graphics";
+import type { GraphicsSymbolDefinition } from "./definition.js";
+export declare function symbolField(field: TSchema): {
+    type: string;
+    title: string | undefined;
+    default: unknown;
+    minimum: number | undefined;
+    maximum: number | undefined;
+    color: boolean;
+    choices: {
+        value: string;
+        label: string;
+    }[];
+};
+export type PropertyGroup = "essential" | "readings" | "appearance";
+/** Readings are data a device supplies; labels, units, variants and display toggles are appearance. */
+export declare function propertyGroup(property: string, field: ReturnType<typeof symbolField>, essential: ReadonlySet<string>): PropertyGroup;
+/** Whether a property can follow a parameter: readings and states, not labels or display options. */
+export declare function graphicsSymbolPropertyBindable(group: PropertyGroup, field: ReturnType<typeof symbolField>): boolean;
+export interface GraphicsSymbolField {
+    property: string;
+    field: ReturnType<typeof symbolField>;
+    group: PropertyGroup;
+}
+/** The symbol's declared properties with their inspector group, in declaration order. */
+export declare function graphicsSymbolFields(definition: GraphicsSymbolDefinition): GraphicsSymbolField[];
+/** One symbol property: its binding when bound, otherwise its value with link and reset buttons. */
+export declare function GraphicsSymbolPropertyEditor({ entry: { property, field, group }, element, workspaceId, document, onChange, }: {
+    entry: GraphicsSymbolField;
+    element: Extract<GraphicsElement, {
+        kind: "symbol";
+    }>;
+    workspaceId: string;
+    document: GraphicsDocument;
+    onChange: (document: GraphicsDocument) => void;
+}): import("react").JSX.Element;
+/** Values and bindings the symbol no longer declares, each with a button that removes it. */
+export declare function GraphicsSymbolInvalidProperties({ element, definition, document, onChange, }: {
+    element: Extract<GraphicsElement, {
+        kind: "symbol";
+    }>;
+    definition: GraphicsSymbolDefinition;
+    document: GraphicsDocument;
+    onChange: (document: GraphicsDocument) => void;
+}): import("react").JSX.Element[];

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

@@ -0,0 +1,12 @@
+import { type ReactNode } from "react";
+import { type GraphicsSymbolGeometries } from "@overvis/hmi-shared/graphics";
+import { type GraphicsSymbolDefinition } from "./definition.js";
+export declare function GraphicsSymbolsProvider({ symbols, children, }: {
+    symbols: readonly GraphicsSymbolDefinition[];
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useGraphicsSymbols(): ReadonlyMap<string, GraphicsSymbolDefinition>;
+/** Port geometry by symbol ID, for the shared transformation rules. */
+export declare function graphicsSymbolGeometries(symbols: ReadonlyMap<string, GraphicsSymbolDefinition>): GraphicsSymbolGeometries;
+/** Inspect the catalog exported by a dynamically loaded dashboard module. */
+export declare function isGraphicsSymbolDefinition(value: unknown): value is GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/pump-status-icon.d.ts

@@ -0,0 +1,5 @@
+export declare function PumpStatusIcon({ running, fault, className, }: {
+    running: boolean | null;
+    fault: boolean | null;
+    className?: string;
+}): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,63 @@
+import { type ComponentProps } from "react";
+/** Shared equipment status palette; always pair it with text or shape. */
+export declare const graphicsStatusColors: {
+    readonly inactive: "#94a3b8";
+    readonly operating: "#159b78";
+    readonly warning: "#d49a38";
+    readonly fault: "#dc5656";
+    readonly unknown: "#cbd5e1";
+};
+/** Motion runs only while every property driving it is fresh and the drawing is not edited. */
+export declare function useGraphicsSymbolMotion(...properties: string[]): boolean;
+/** A bound flag whose value is unavailable; a static or stale flag is known. */
+export declare function useGraphicsSymbolUnknown(property: string): boolean;
+/**
+ * One numeric reading, placed inside an SVG `<text>`: "—" when unavailable, the binding's
+ * precision, and the stale tone. `unit` is a unit property's value and is shown as given;
+ * otherwise the bound parameter's units win over the symbol's `defaultUnit`.
+ */
+export declare function Reading({ property, value, unit, defaultUnit, invalid, digits, }: {
+    property: string;
+    value: number;
+    unit?: string | undefined;
+    defaultUnit?: string;
+    /**
+     * The instrument itself reports a fault or lost communication, so its last number is not a
+     * measurement: shown as "—" like an unavailable reading.
+     */
+    invalid?: boolean;
+    /** Fraction digits while the binding sets no precision, as for a power factor's "0.96". */
+    digits?: number;
+}): import("react").JSX.Element;
+/**
+ * A reading with an optional leading label, or readings joined by their own separator under one
+ * optional label, as in "Flow/return 45 °C/35 °C".
+ */
+export type GraphicsReadingEntry = (ComponentProps<typeof Reading> & {
+    label?: string;
+}) | {
+    separator: string;
+    readings: readonly GraphicsReadingEntry[];
+    label?: string;
+};
+/**
+ * Whether a reading shows: an essential reading always does; an optional one only once the
+ * placement binds or sets it, so its schema default never looks like a value.
+ */
+export declare function useGraphicsSymbolReadingShown(property: string): boolean;
+/**
+ * Readings joined by `separator`. An optional reading the placement neither binds nor sets is left
+ * out with its separator instead of showing its schema default; essential readings always show.
+ * Give every entry of a row with more than one reading a `label`, so a left-out reading never
+ * shifts meaning onto its neighbour.
+ */
+export declare function Readings({ readings, separator, }: {
+    readings: readonly GraphicsReadingEntry[];
+    separator?: string;
+}): import("react").JSX.Element[];
+/** A neutral "?" badge for an equipment state that cannot be determined. */
+export declare function GraphicsUnknownMark({ x, y, r }: {
+    x: number;
+    y: number;
+    r?: number;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/symbols/quarry/belt-scale.d.ts

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

package/dist/src/workspace/graphics/symbols/quarry/chute.d.ts

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

package/dist/src/workspace/graphics/symbols/quarry/crusher.d.ts

@@ -0,0 +1,2 @@
+export declare const crusherBodies: readonly ["jaw", "cone", "impact"];
+export declare const crusher: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/quarry/diverter-gate.d.ts

@@ -0,0 +1,2 @@
+export declare const diverterDestinations: readonly ["a", "b", "moving", "unknown"];
+export declare const diverterGate: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/quarry/dust-collector.d.ts

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

package/dist/src/workspace/graphics/symbols/quarry/feeder.d.ts

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

package/dist/src/workspace/graphics/symbols/quarry/hopper.d.ts

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

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

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

package/dist/src/workspace/graphics/symbols/quarry/parts.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from "react";
+/** Crushed stone filling hoppers and piles. */
+export declare const aggregateFill = "#d3c9b8";
+/** Outline of the material inside a vessel or pile. */
+export declare const aggregateEdge = "#a8997f";
+/** Steel structure drawn around equipment: legs, frames, supports. */
+export declare const structureStroke = "#94a3b8";
+/** Limit alarm text over material: a darker amber than the status mark, so it reads on the fill. */
+export declare const limitText = "#b45309";
+/**
+ * Lines of text stacked downwards from `y` inside a vessel, on a pale backing so they read over
+ * the material. Empty entries are skipped without leaving a gap.
+ */
+export declare function StackedText({ x, y, lines, }: {
+    x: number;
+    y: number;
+    lines: readonly (ReactNode | null | false)[];
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/symbols/quarry/screen.d.ts

@@ -0,0 +1,2 @@
+export declare const screenDecks: readonly ["single", "double", "triple"];
+export declare const screen: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/quarry/spray-suppression.d.ts

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

package/dist/src/workspace/graphics/symbols/quarry/stockpile.d.ts

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

package/dist/src/workspace/graphics/symbols/quarry/trommel.d.ts

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

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

@@ -0,0 +1,3 @@
+import type { GraphicsSymbolPropertyState } from "./viewport.js";
+/** Format a numeric readout: "—" when unknown, the binding's precision otherwise. */
+export declare function formatGraphicsSymbolReading(value: number, state: GraphicsSymbolPropertyState, locale?: string): string;

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

@@ -0,0 +1,12 @@
+import type { GraphicsSymbolPropertyState } from "./viewport.js";
+import { type GraphicsElement } from "@overvis/hmi-shared/graphics";
+import { type GraphicsSymbolDefinition } from "./definition.js";
+export declare function GraphicsSymbolArtwork({ element, definition, editing, bindings, }: {
+    element: Extract<GraphicsElement, {
+        kind: "symbol";
+    }>;
+    definition: GraphicsSymbolDefinition | undefined;
+    editing: boolean;
+    /** Live state of bound properties; omitted for static previews. */
+    bindings?: Readonly<Record<string, GraphicsSymbolPropertyState>>;
+}): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,7 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import type { GraphicsSymbolDetails, GraphicsSymbolManifest } from "@overvis/hmi-shared/graphics";
+import type { GraphicsSymbolDefinition } from "./definition.js";
+/** Serialize symbol definitions with their text in `locale`; the UI language is unchanged. */
+export declare function serializeGraphicsSymbolCatalog(definitions: readonly GraphicsSymbolDefinition[], locale: AppLocale): Promise<GraphicsSymbolDetails[]>;
+/** Serialize symbol definitions in every application locale. */
+export declare function serializeGraphicsSymbolManifest(definitions: readonly GraphicsSymbolDefinition[]): Promise<GraphicsSymbolManifest>;

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

@@ -0,0 +1,47 @@
+import { graphicsStatusColors } from "./quality.js";
+/**
+ * The library's presentation contract for equipment state:
+ * - One status mark: a coloured dot with a glyph, so state never relies on colour alone
+ *   (× fault, ! warning, − inactive, ? unknown, plain dot operating).
+ * - A status line appears only while the placement binds or sets a state input; passive
+ *   equipment shows nothing until it has something to say.
+ * - An alarm joins the operating state instead of replacing it: "Warning · Heating".
+ * - Motion follows running feedback and data quality, never the alarm state.
+ * - Large shapes stay neutral in normal operation; colour fills are for warning and fault.
+ * - The body's top-right corner is kept free for the host's data-quality badge.
+ */
+export type GraphicsSymbolStatus = keyof typeof graphicsStatusColors;
+/** Text tinted by status; neutral states use a legible slate instead of the pale fill colour. */
+export declare function graphicsStatusTextColor(status: GraphicsSymbolStatus): string;
+export declare function GraphicsStatusMark({ x, y, status, r, }: {
+    x: number;
+    y: number;
+    status: GraphicsSymbolStatus;
+    r?: number;
+}): import("react").JSX.Element;
+/** A warning or fault flag raises its indication only while its value is known. */
+export declare function useGraphicsSymbolAlarm(property: string, value: boolean): boolean;
+/** Whether the placement binds or sets any of these state inputs, so a status line is due. */
+export declare function useGraphicsSymbolStatusShown(...properties: string[]): boolean;
+/**
+ * One status text: the alarm first, then the operating state it interrupts, as in
+ * "Warning · Heating". Either part may be missing.
+ */
+export declare function graphicsStatusText(operating?: string | null, alarm?: string | null): string;
+/**
+ * A status text that fits `available` units at `fontSize`, estimated from its length since SVG
+ * text cannot be measured while rendering. A joined text that nearly fits is condensed slightly;
+ * one that does not drops the operating part so the alarm stays readable. Pass the returned
+ * `textLength` with `lengthAdjust="spacingAndGlyphs"` when present.
+ */
+export declare function fitGraphicsStatusText(operating: string | null | undefined, alarm: string | null | undefined, fontSize: number, available: number): {
+    text: string;
+    textLength?: number;
+};
+/** A limit alarm mark: an arrow up for a high limit, down for a low one, so the two differ. */
+export declare function GraphicsLimitMark({ x, y, limit, r, }: {
+    x: number;
+    y: number;
+    limit: "high" | "low";
+    r?: number;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/symbols/thermal/furnace.d.ts

@@ -0,0 +1,28 @@
+import Type, { type Static } from "typebox";
+import { type OperatingState } from "../hvac/index.js";
+/** Process stages shared by ovens, furnaces and kilns. */
+export declare const thermalStageProperty: () => Type.TUnion<[Type.TLiteral<"idle">, Type.TLiteral<"heating">, Type.TLiteral<"soaking">, Type.TLiteral<"cooling">, Type.TLiteral<"complete">, Type.TLiteral<"unknown">]>;
+export type ThermalStage = Static<ReturnType<typeof thermalStageProperty>>;
+export declare const thermalStages: readonly ThermalStage[];
+export declare function thermalStageName(stage: ThermalStage): string;
+/**
+ * Known alarms outrank the stage: a fault, then a tripped overtemperature limit (red, with its own
+ * caption), then a warning. Otherwise the stage decides: a cycle in progress is operating, idle and
+ * complete are inactive. Unavailable flags show nothing alarming.
+ */
+export declare function useThermalStatus(p: {
+    stage: ThermalStage;
+    fault: boolean;
+    warning: boolean;
+    overtemperature?: boolean;
+}, stageName?: (stage: ThermalStage) => string): {
+    state: OperatingState;
+    status: string | undefined;
+    alarmStatus: string | undefined;
+    /** Whether an alarm joins the stage, as in "Warning · Heating": any stage but idle. */
+    alarmJoins: boolean;
+    hot: boolean;
+};
+/** Chamber tint: glowing while heating or soaking, warm while cooling, neutral otherwise. */
+export declare function chamberFill(stage: ThermalStage, stageUnknown: boolean): "#f1f5f9" | "#f4b98c" | "#f8dcc6";
+export declare const furnace: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/thermal/heater.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A heating core's glow: a red-orange well away from the warning amber, so a normally heating
+ * element never reads as an alarm.
+ */
+export declare const heaterGlow = "#e2704f";
+export declare const heater: import("../definition.js").GraphicsSymbolDefinition;

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

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

package/dist/src/workspace/graphics/symbols/thermal/kiln.d.ts

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

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

@@ -0,0 +1,68 @@
+import { type ReactNode, type SVGProps } from "react";
+type TextProps = Omit<SVGProps<SVGTextElement>, "x" | "y" | "fontSize"> & {
+    x: number | string;
+    y: number | string;
+    /**
+     * Used to find the middle of the line; defaults to 12. Pass it, and `textAnchor`, on the text
+     * itself: values inherited from a parent group are not visible here.
+     */
+    fontSize?: number | string;
+};
+/**
+ * SVG text that stays upright and unmirrored however the symbol is placed. It turns around the
+ * middle of its line, and start/end anchors follow the artwork so text keeps growing away from
+ * what it labels.
+ */
+export declare function GraphicsSymbolText({ textAnchor, ...props }: TextProps): import("react").JSX.Element;
+/**
+ * A block of artwork kept upright and unmirrored around a point, such as a display face or a
+ * stack of readings: its internal layout stays readable however the symbol is placed. Text inside
+ * keeps the block's layout.
+ */
+export declare function GraphicsSymbolUpright({ x, y, children, }: {
+    x: number;
+    y: number;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * The block of tag and status lines below the artwork, with its status marks. Mirroring and a half
+ * turn flip only the artwork: the block is drawn exactly as on an unturned, unmirrored placement,
+ * in the same place, so the marker stays left of its text and the tag above the status. After a
+ * quarter turn the captions inside move outside the placement on their own. `width`, `height`,
+ * `left` and `top` describe the SVG viewBox.
+ */
+export declare function GraphicsSymbolCaptionBlock({ width, height, left, top, children, }: {
+    width: number;
+    height: number;
+    left?: number;
+    top?: number;
+    children: ReactNode;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;
+/** Whether a quarter turn has made the artwork's bottom strip vertical, moving captions outside. */
+export declare function useGraphicsSymbolSideways(): boolean;
+/** The direction in the artwork's own frame that points down the drawing. */
+export declare function useGraphicsSymbolDrawingDown(): {
+    x: number;
+    y: number;
+};
+/** Upright text that keeps its size in the drawing when a proportional symbol is resized. */
+export declare function GraphicsSymbolUnscaledText(props: TextProps): import("react").JSX.Element;
+/**
+ * A label drawn in a strip of the artwork, normally along its bottom edge. When a quarter turn
+ * makes that strip vertical, the label moves outside the placement to the first side without a
+ * port: below, right, above, then left. `width` and `height` are the SVG viewBox size, and `left`
+ * and `top` its origin when the artwork has margins. Further caption lines of the same strip pass
+ * `line` to stack outside in reading order. A resized proportional symbol keeps its captions at
+ * their natural size.
+ */
+export declare function GraphicsSymbolCaption({ width, height, left, top, x, y, gap, line, ...props }: Omit<TextProps, "x" | "y"> & {
+    width: number;
+    height: number;
+    left?: number;
+    top?: number;
+    x?: number | string;
+    y?: number | string;
+    gap?: number;
+    line?: number;
+}): import("react").JSX.Element;
+export {};

package/dist/src/workspace/graphics/symbols/variant-field.d.ts

@@ -0,0 +1,17 @@
+import type { GraphicsDocument, GraphicsElement } from "@overvis/hmi-shared/graphics";
+import type { GraphicsSymbolDefinition } from "./definition.js";
+type SymbolElement = Extract<GraphicsElement, {
+    kind: "symbol";
+}>;
+/**
+ * Properties the Variant field sets, such as a valve's `body`. The inspector leaves them out of
+ * the property list, so one choice is not offered twice.
+ */
+export declare function graphicsSymbolVariantProperties(element: SymbolElement, symbols: ReadonlyMap<string, GraphicsSymbolDefinition>): ReadonlySet<string>;
+/** Switch a placed symbol between drawings that keep its connections and bindings. */
+export declare function GraphicsSymbolVariantField({ element, document, onChange, }: {
+    element: SymbolElement;
+    document: GraphicsDocument;
+    onChange: (document: GraphicsDocument) => void;
+}): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1,30 @@
+import { type GraphicsDocument, type GraphicsElement } from "@overvis/hmi-shared/graphics";
+import { type GraphicsSymbolDefinition } from "./definition.js";
+type SymbolElement = Extract<GraphicsElement, {
+    kind: "symbol";
+}>;
+type Preset = NonNullable<NonNullable<GraphicsSymbolDefinition["catalog"]>["variants"]>[number];
+/** One drawing a placement can switch to: a symbol, optionally with one of its variant presets. */
+export interface GraphicsSymbolVariantChoice {
+    symbol: GraphicsSymbolDefinition;
+    variant: Preset | null;
+}
+/** Whether `preset` describes the placement's current drawing, defaults included. */
+export declare function graphicsSymbolVariantSelected(element: SymbolElement, definition: GraphicsSymbolDefinition, preset: Preset): boolean;
+/**
+ * Another symbol can replace the placement when it belongs to the same family, has the same named
+ * ports and the same key properties, and declares every bound property with the same shape. So no
+ * connection or binding breaks, and a shutoff valve does not turn into a check valve.
+ */
+export declare function graphicsSymbolCompatible(element: SymbolElement, current: GraphicsSymbolDefinition, candidate: GraphicsSymbolDefinition): boolean;
+/**
+ * Drawings the placement can switch to while keeping its bindings and connections: the symbol's
+ * own variants, then compatible symbols of the same family with their variants.
+ */
+export declare function graphicsSymbolVariantChoices(element: SymbolElement, symbols: ReadonlyMap<string, GraphicsSymbolDefinition>): GraphicsSymbolVariantChoice[];
+/**
+ * Switch a placement to another drawing. The placement keeps its identity, center, orientation,
+ * scale, bindings and connections; property values the new drawing does not accept are dropped.
+ */
+export declare function switchGraphicsSymbolVariant(document: GraphicsDocument, element: SymbolElement, choice: GraphicsSymbolVariantChoice, symbols: ReadonlyMap<string, GraphicsSymbolDefinition>): GraphicsDocument;
+export {};

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

@@ -0,0 +1,43 @@
+import type { GraphicsQuality } from "../binding-value.js";
+import type { GraphicsElement, GraphicsPortSide } from "@overvis/hmi-shared/graphics";
+/** Live state of one bound property. Unbound properties are fresh static values. */
+export interface GraphicsSymbolPropertyState {
+    quality: GraphicsQuality;
+    /** Readout precision configured on the binding. */
+    digits?: number;
+    /** Localized units of the bound parameter. */
+    units?: string;
+}
+export type GraphicsSymbolViewport = Pick<GraphicsElement, "width" | "height" | "rotation"> & {
+    /** Mirroring in the symbol's own frame, applied before rotation. */
+    mirrorX: boolean;
+    mirrorY: boolean;
+    /** Drawing sides where the placement has ports, after rotation and mirroring. */
+    portSides: readonly GraphicsPortSide[];
+    editing: boolean;
+    /**
+     * How much a proportional symbol is enlarged from its natural size, which scales its artwork;
+     * captions divide it out to keep their size. 1 for stretchable symbols, which draw at size.
+     */
+    scale?: number;
+    /** Keyed by property name; a stale property keeps its value, an unknown one keeps its default. */
+    bindings: Readonly<Record<string, GraphicsSymbolPropertyState>>;
+};
+export declare const GraphicsSymbolViewportContext: import("react").Context<GraphicsSymbolViewport | null>;
+/**
+ * Properties the placement sets or binds, whose unassigned rest render their schema defaults, and
+ * the catalog's essential properties.
+ */
+export declare const GraphicsSymbolAssignmentContext: import("react").Context<{
+    assigned: ReadonlySet<string>;
+    essential: ReadonlySet<string>;
+}>;
+/** Render dimensions in drawing units, before the viewer's uniform zoom. */
+export declare function useGraphicsSymbolViewport(): GraphicsSymbolViewport;
+/**
+ * Data quality, precision and parameter units of one property, and whether the placement assigns
+ * it. An unassigned property is its schema default, not a value from the placement or equipment.
+ */
+export declare function useGraphicsSymbolProperty(name: string): GraphicsSymbolPropertyState & {
+    assigned: boolean;
+};

package/dist/src/workspace/graphics/symbols/warehouse/agv.d.ts

@@ -0,0 +1,4 @@
+/** The gauge's filled width for a supplied charge; out-of-range charges stop at empty or full. */
+export declare function batteryFill(value: number): number;
+declare const _default: import("../definition.js").GraphicsSymbolDefinition;
+export default _default;

package/dist/src/workspace/graphics/symbols/warehouse/cold-room.d.ts

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

package/dist/src/workspace/graphics/symbols/warehouse/cooling-unit.d.ts

@@ -0,0 +1,19 @@
+import Type, { type Static } from "typebox";
+declare const properties: () => Type.TObject<{
+    label: Type.TString;
+    running: Type.TBoolean;
+    defrost: Type.TBoolean;
+    warning: Type.TBoolean;
+    fault: Type.TBoolean;
+    animate: Type.TBoolean;
+}>;
+type CoolingUnitProperties = Static<ReturnType<typeof properties>>;
+/** A known defrost cycle is an active state of its own; the fans stand still while it runs. */
+export declare function useDefrostState(p: Pick<CoolingUnitProperties, "running" | "fault" | "warning" | "defrost"> & {
+    label: string;
+}, defrostProperty?: string): {
+    readonly state: "fault" | "inactive" | "operating" | "unknown" | "warning";
+    readonly defrosting: boolean;
+};
+declare const _default: import("../definition.js").GraphicsSymbolDefinition;
+export default _default;

package/dist/src/workspace/graphics/symbols/warehouse/door.d.ts

@@ -0,0 +1,61 @@
+import Type, { type Static } from "typebox";
+/** Which way a moving door travels, when its controller reports it. */
+export declare const doorDirectionProperty: (title: string) => Type.TUnion<[Type.TLiteral<"unreported">, Type.TLiteral<"opening">, Type.TLiteral<"closing">]>;
+export type DoorDirection = Static<ReturnType<typeof doorDirectionProperty>>;
+/** The opening as a 0–1 fraction, or null when the input that drives it is unavailable. */
+export declare function useDoorOpening({ open, positionFeedback, position, openProperty, positionProperty, modeProperty, }: {
+    open: boolean;
+    positionFeedback: boolean;
+    position: number;
+    openProperty?: string;
+    positionProperty?: string;
+    /** The property that chooses position feedback, when the symbol can bind it. */
+    modeProperty?: string;
+}): number | null;
+/**
+ * A reported travel direction, or "unreported" while the input is unavailable, so a stale guess
+ * never points the wrong way.
+ */
+export declare function useKnownDirection<T extends string>(property: string, value: T): T | "unreported";
+/**
+ * A motion arrow centred on (`x`, `y`) along one axis. It points toward the axis start (up or
+ * left), the end (down or right), or both ways when the direction is not reported.
+ */
+export declare function MotionArrow({ x, y, length, axis, toward, color, head, }: {
+    x: number;
+    y: number;
+    length: number;
+    axis: "vertical" | "horizontal";
+    toward: "start" | "end" | "both";
+    color: string;
+    head?: number;
+}): import("react").JSX.Element;
+/**
+ * A plan-view swing leaf hinged at (`hinge`, `bottom`) in a wall running up to `top`; the open
+ * leaf lies along the floor toward `end`. While it moves in a reported direction an arrowhead on
+ * the swing arc shows which way.
+ */
+export declare function SwingLeaf({ hinge, top, bottom, end, opening, moving, direction, }: {
+    hinge: number;
+    top: number;
+    bottom: number;
+    end: number;
+    opening: number | null;
+    moving: boolean;
+    direction?: DoorDirection;
+}): import("react").JSX.Element;
+/**
+ * A roller shutter or sectional door in elevation, filling `x`…`x + width` and `top`…`floor`.
+ * The curtain retracts upward by the opening fraction.
+ */
+export declare function ShutterLeaf({ x, top, width, floor, opening, moving, sectional, }: {
+    x: number;
+    top: number;
+    width: number;
+    floor: number;
+    opening: number | null;
+    moving: boolean;
+    sectional?: boolean;
+}): import("react").JSX.Element;
+declare const _default: import("../definition.js").GraphicsSymbolDefinition;
+export default _default;

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

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

package/dist/src/workspace/graphics/symbols/warehouse/loading-dock.d.ts

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

package/dist/src/workspace/graphics/symbols/warehouse/pallet.d.ts

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

package/dist/src/workspace/graphics/symbols/warehouse/rack.d.ts

@@ -0,0 +1,25 @@
+import Type, { type Static } from "typebox";
+/** One bit per location for the largest rack: 6 levels × 4 bays. */
+export declare const rackMaskMaximum: number;
+declare const properties: () => Type.TObject<{
+    label: Type.TString;
+    levels: Type.TInteger;
+    bays: Type.TInteger;
+    occupancySource: Type.TUnion<[Type.TLiteral<"count">, Type.TLiteral<"mask">]>;
+    occupied: Type.TInteger;
+    occupancyMask: Type.TInteger;
+    blockedMask: Type.TInteger;
+    showCapacity: Type.TBoolean;
+}>;
+type RackProperties = Static<ReturnType<typeof properties>>;
+/** Whether the location's bit is set; bit 0 is the bottom-left location, then along the level. */
+export declare function rackMaskHas(mask: number, level: number, bay: number, bays: number): boolean;
+/** The set locations of a mask within the rack's levels and bays. */
+export declare function rackMaskCount(mask: number, levels: number, bays: number): number;
+/**
+ * Occupied locations as `[level from the bottom][bay from the left]`. A count fills locations in
+ * reading order from the top-left.
+ */
+export declare function rackOccupancy(p: Pick<RackProperties, "levels" | "bays" | "occupancySource" | "occupied" | "occupancyMask">): boolean[][];
+declare const _default: import("../definition.js").GraphicsSymbolDefinition;
+export default _default;

package/dist/src/workspace/graphics/symbols/warehouse/stacker-crane.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Carriage top at 0 % and 100 %: the travel spans the height of a rack beside it. The lift's
+ * load stands on its carriage, so its carriage stops lower, keeping the load under the header.
+ */
+declare const highest: {
+    readonly "stacker-crane": 14;
+    readonly "vertical-lift": 22;
+};
+/** The carriage's top edge for a supplied position; out-of-range positions stop at the ends. */
+export declare function craneCarriageTop(position: number, variant?: keyof typeof highest): number;
+declare const _default: import("../definition.js").GraphicsSymbolDefinition;
+export default _default;