@weasel-js/labkit 1.6.0 → 1.7.0

package/dist/_dts/index-B2Yj5aA0.d.ts

@@ -0,0 +1,274 @@
+import './FloatingPanel-7j0IcXwz.js';
+import * as react from 'react';
+import { ReactNode, MouseEventHandler } from 'react';
+import { J as JobHandle } from './types-DJ79Tg5J.js';
+
+/** Whether a row's label sits beside its value or above it. */
+type DetailListLayout = 'inline' | 'block';
+/**
+ * How a list sets its values. `text` starts each value at the column's edge
+ * and wraps it; `figures` right-aligns it in a column at least
+ * `--wzl-detail-figure-min-width` (default `8ch`) wide, in the mono face,
+ * with spaces kept, so figure-space padding lines a column up on its decimal
+ * point.
+ */
+type DetailListValues = 'text' | 'figures';
+/** The state a row's status dot reports, painted from `--wzl-success`,
+ *  `--wzl-warning` or `--wzl-danger`. */
+type DetailRowStatus = 'success' | 'warn' | 'danger';
+/** Props for {@link DetailList}. */
+interface DetailListProps {
+    /** {@link DetailRow}s. */
+    children: ReactNode;
+    /** Heading drawn above the list, which also names it. */
+    title?: ReactNode;
+    /**
+     * `inline` puts every label in one rail beside the values; `block` stacks
+     * each label over its value, for a column too narrow to hold both.
+     */
+    layout?: DetailListLayout;
+    /** `text` by default. See {@link DetailListValues}. */
+    values?: DetailListValues;
+    /** Class on the outermost element: the `<dl>`, or the `<section>` holding
+     *  the heading and the list when there is a `title`. */
+    className?: string;
+}
+/** Props for {@link DetailRow}. */
+interface DetailRowProps {
+    label: ReactNode;
+    /** The value: text, or any run of elements — code chips, badges, keycaps,
+     *  links. Several children wrap as a line of items. `null` or `undefined`
+     *  keeps the row in place showing `placeholder`, so a list whose values
+     *  come and go holds its height. */
+    children?: ReactNode;
+    /** Shown while there is no value. An en dash by default. */
+    placeholder?: ReactNode;
+    /**
+     * Draws a dot in the status color before the value. The dot is hidden from
+     * assistive technology and color is never the only signal, so the value
+     * itself has to say the same thing — "locked", not just a green dot.
+     */
+    status?: DetailRowStatus;
+    /** Sets this row's value as `text` or `figures`, whatever the list's
+     *  `values` says — a sentence among figures, or one figure among text. */
+    values?: DetailListValues;
+    className?: string;
+}
+/**
+ * A read-only list of labeled values — the `<dl>` a property panel would be
+ * if its rows held facts instead of controls. Labels take the params label
+ * recipe and rail: `--wzl-params-label-width` sets the rail, so a detail list
+ * and a property panel beside it line their labels up from one declaration.
+ */
+declare function DetailList({ children, title, layout, values, className }: DetailListProps): react.JSX.Element;
+/** One label and its value in a {@link DetailList}. */
+declare function DetailRow({ label, children, placeholder, status, values, className }: DetailRowProps): react.JSX.Element;
+
+/** A live frame-rate readout, averaged over the last 30 frames. */
+declare function FpsMeter(): react.JSX.Element;
+
+/** Props for `<JobProgress>`. */
+interface JobProgressProps {
+    job: JobHandle;
+    className?: string;
+}
+/** A running job's progress, failures and outcome. Determinate once the job
+ *  reports a total; a job that cannot count up front never sends one, so the
+ *  bar stays indeterminate rather than inventing a denominator. */
+declare function JobProgress({ job, className }: JobProgressProps): react.JSX.Element | null;
+
+/** How a legend entry's swatch is drawn, matching how the thing looks on canvas. */
+type LegendMark = 'line' | 'dash' | 'dot' | 'band';
+/** One row of a legend: a swatch and what it means. */
+interface LegendEntry {
+    key: string;
+    label: string;
+    color: string;
+    /** Defaults to `'line'`. */
+    mark?: LegendMark;
+}
+/** Props for `<Legend>`. */
+interface LegendProps {
+    entries: readonly LegendEntry[];
+    className?: string;
+}
+/** A color key. Presentational only — no handlers, no state, no hover behavior. */
+declare function Legend({ entries, className }: LegendProps): react.JSX.Element;
+
+/** One measurement in a {@link Readout}. */
+interface ReadoutRow {
+    /** React key. Defaults to `label` when that is a string, else the row's index. */
+    key?: string;
+    label: ReactNode;
+    /** `null` or `undefined` keeps the row in place showing an en dash, so the
+     *  readout holds its height while a measurement comes and goes. */
+    value?: ReactNode;
+    /** A dot in the status color before the value. Color is never the only
+     *  signal: the value has to say the same thing in words. */
+    status?: DetailRowStatus;
+    /** `text` sets this row's value as wrapping prose instead of a figure. */
+    values?: DetailListValues;
+}
+/** Props for {@link Readout}. */
+interface ReadoutProps {
+    rows: readonly ReadoutRow[];
+    /** Heading above the rows, which also names the list. */
+    title?: ReactNode;
+    /** Drawn below the rows — a small table, a note. */
+    children?: ReactNode;
+    className?: string;
+}
+/**
+ * Values a lab only reads — measurements shown beside its picture, such as
+ * "Lock margin +47.9°". A {@link DetailList} set as figures: labels take the
+ * params label recipe and `--wzl-params-label-width` rail, so a readout lines
+ * up with a `ControlPanel` beside it, and values sit right-aligned in the mono
+ * face with spaces kept, so figure-space padding aligns a column on its
+ * decimal point. Rows compose by hand as `DetailRow`s inside a `DetailList`
+ * with `values="figures"`.
+ */
+declare function Readout({ rows, title, children, className }: ReadoutProps): react.JSX.Element;
+
+/** Props for `<ScaleIndicator>`. */
+interface ScaleIndicatorProps {
+    /** Current view zoom factor. If omitted, reads from CanvasStackContext. Defaults to 1. */
+    zoom?: number;
+    /** World pixels per unit at zoom=1. Default: 1. */
+    pixelsPerUnit?: number;
+    /** Unit label. Default: 'px'. */
+    unit?: string;
+    /** Target bar width in display pixels. Default: 100. */
+    targetWidth?: number;
+}
+/** A scale bar: a labeled rule showing how far a round number of world units
+ *  is at the current zoom. Reads the zoom from the surrounding canvas stack
+ *  unless one is passed. */
+declare function ScaleIndicator({ zoom, pixelsPerUnit, unit, targetWidth, }: ScaleIndicatorProps): react.JSX.Element;
+
+/** Props for `<Split>`. */
+interface SplitProps {
+    /** The sidebar pane's contents. */
+    sidebar: ReactNode;
+    /** The edge the sidebar sits on. Read once, when the strip mounts. Default `'start'`. */
+    side?: 'start' | 'end';
+    /** The content pane's contents. */
+    children: ReactNode;
+    /** Names the sidebar pane, and through it the seam. Default `'Sidebar'`. */
+    label?: string;
+    /** Extra classes on the strip, which always has `lk-split`. */
+    className?: string;
+    /** The class on the sidebar pane. */
+    sidebarClassName?: string;
+    /** The class on the content pane. */
+    contentClassName?: string;
+    /** The sidebar's current extent in pixels. Omit to leave it unpersisted: the
+     *  seam still works, its result just does not outlive the mount. */
+    width?: number;
+    /** Where the sidebar starts before anyone drags it. */
+    defaultWidth?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    /** How little the content pane may be squeezed to. Reported as the seam's
+     *  reachable maximum, so the drag stops there rather than clamping silently. */
+    contentMinWidth?: number;
+    /** Fires through the drag, not on release: the pane is already there. */
+    onWidthChange?: (width: number) => void;
+    /**
+     * Fixed extent. Omit in an app — the strip measures its own box. Supply it
+     * where nothing measures, notably jsdom, or both panes lay out at zero.
+     */
+    viewport?: {
+        w: number;
+        h: number;
+    };
+}
+/**
+ * A sidebar and a content pane as a two-pane strip with a draggable seam.
+ *
+ * The seam is `stripStrategy`'s own resize affordance, so it arrives as a
+ * `role="separator"` carrying the reachable range, operable by pointer and by
+ * arrows / Home / End, and clamped against the content pane's floor rather
+ * than against the sidebar's alone.
+ */
+declare function Split({ sidebar, children, side, label, className, sidebarClassName, contentClassName, width, defaultWidth, minWidth, maxWidth, contentMinWidth, onWidthChange, viewport, }: SplitProps): react.JSX.Element;
+
+/** Props for `<StatusBar>`. */
+interface StatusBarProps {
+    children: ReactNode;
+}
+/** A footer strip for readouts. Fill it with `<StatusBar.Section>`. */
+declare function StatusBar({ children }: StatusBarProps): react.JSX.Element;
+declare namespace StatusBar {
+    var Section: ({ children, end }: StatusBarSectionProps) => react.JSX.Element;
+}
+/** Props for `<StatusBar.Section>`. */
+interface StatusBarSectionProps {
+    children: ReactNode;
+    /** Pushes this section, and everything after it, to the far end. */
+    end?: boolean;
+}
+
+/** Props for `<Toolbar>`. */
+interface ToolbarProps {
+    children: ReactNode;
+    /** Names the toolbar for assistive tech. Required by the APG pattern when a
+     *  view holds more than one. */
+    'aria-label'?: string;
+}
+/** A horizontal bar of controls. Fill it with `<Toolbar.Title>`,
+ *  `<Toolbar.Group>`, `<Toolbar.Button>` and `<Toolbar.Spacer>`. */
+declare function Toolbar({ children, 'aria-label': ariaLabel }: ToolbarProps): react.JSX.Element;
+declare namespace Toolbar {
+    var Title: ({ children }: TitleProps) => react.JSX.Element;
+    var Group: ({ children, end, "aria-label": ariaLabel }: ToolbarGroupProps) => react.JSX.Element;
+    var Button: ({ children, onClick, disabled, title, "aria-label": ariaLabel, variant, iconOnly, pressed, }: ToolbarButtonProps) => react.JSX.Element;
+    var Spacer: () => react.JSX.Element;
+}
+interface TitleProps {
+    children: ReactNode;
+}
+/** Props for `<Toolbar.Group>`. */
+interface ToolbarGroupProps {
+    children: ReactNode;
+    /** Pushes this group, and everything after it, to the far end. */
+    end?: boolean;
+    'aria-label'?: string;
+}
+/** Props for `<Toolbar.Button>`. */
+interface ToolbarButtonProps {
+    children: ReactNode;
+    onClick: MouseEventHandler<HTMLButtonElement>;
+    disabled?: boolean;
+    title?: string;
+    /** Required when `children` is an icon with no text of its own. */
+    'aria-label'?: string;
+    /** `danger` reddens on hover — for actions that discard work. */
+    variant?: 'default' | 'danger';
+    /** Square, for a button whose whole content is one glyph. */
+    iconOnly?: boolean;
+    /** Makes this a toggle: `aria-pressed`, and held down while true. */
+    pressed?: boolean;
+}
+
+/** Props for `<ZoomControl>`. */
+interface ZoomControlProps {
+    /** Current zoom as a scale factor: 1 is actual size. */
+    zoom: number;
+    /** Fired continuously while the slider drags. */
+    onZoomChange: (zoom: number) => void;
+    /** Fired when a drag settles or the field is committed. Defaults to
+     *  `onZoomChange`. */
+    onZoomCommit?: (zoom: number) => void;
+    /** Smallest selectable zoom. Defaults to 0.1 (10%). */
+    min?: number;
+    /** Largest selectable zoom. Defaults to 8 (800%). */
+    max?: number;
+    className?: string;
+}
+/** Zoom as a log-scaled slider with an editable percentage beside it. Pair it
+ *  with zoom-in / zoom-out buttons in a `<Toolbar.Group>`; this component owns
+ *  only the continuous part. */
+declare function ZoomControl({ zoom, onZoomChange, onZoomCommit, min: minProp, max: maxProp, className, }: ZoomControlProps): react.JSX.Element;
+
+export { DetailList as D, FpsMeter as F, JobProgress as J, Legend as L, Readout as R, Toolbar as T, ZoomControl as Z, DetailRow as d, ScaleIndicator as m, Split as o, StatusBar as p };
+export type { SplitProps as S, DetailListLayout as a, DetailListProps as b, DetailListValues as c, DetailRowProps as e, DetailRowStatus as f, JobProgressProps as g, LegendEntry as h, LegendMark as i, LegendProps as j, ReadoutProps as k, ReadoutRow as l, ScaleIndicatorProps as n, StatusBarProps as q, StatusBarSectionProps as r, ToolbarButtonProps as s, ToolbarGroupProps as t, ToolbarProps as u, ZoomControlProps as v };

package/dist/_dts/{index-B0--8PEM.d.ts → index-CsYqUHD3.d.ts}

@@ -1,6 +1,5 @@
-import { C as ControlRenderer, d as ConfigRule } from './types-B7y8hX1D.js';
-import { O as Instrument, as as TrialChromeContext, R as TrialContribution, T as TrialRecord, t as InstrumentList, g as SavedSnapshot, s as LabMode, aq as ToolSlotContext, a6 as ContributionBase, ar as ToolbarItem, ap as ToolItem, aj as SidebarSection, am as StatusReadout, K as TrialTool, af as RegionContribution, ak as SidebarSlotContext } from './frac-DTRq7Xpb.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import { d as ControlRenderer, c as ConfigRule } from './types-CRPSGFAp.js';
+import { R as Instrument, ax as TrialChromeContext, Y as TrialContribution, T as TrialRecord, t as InstrumentList, f as SavedSnapshot, s as LabMode, av as ToolSlotContext, a9 as ContributionBase, aw as ToolbarItem, au as ToolItem, ao as SidebarSection, ar as StatusReadout, O as TrialTool, ak as RegionContribution, ap as SidebarSlotContext } from './types-CSm9jgol.js';
 import * as react from 'react';
 import { ReactNode } from 'react';
 
@@ -142,15 +141,15 @@ interface LabRegionProps {
     contributions: readonly LabContribution[];
 }
 /** The lab's action bar, in the shell header beside the title. */
-declare function LabHeaderRegion({ contributions }: LabRegionProps): react_jsx_runtime.JSX.Element;
+declare function LabHeaderRegion({ contributions }: LabRegionProps): react.JSX.Element;
 /** The lab's sidebar sections. Fold state is a lab-scoped persisted value, so it
  *  survives a reload in a stored lab and lasts the session in an unstored one. */
-declare function LabSidebarRegion({ contributions }: LabRegionProps): react_jsx_runtime.JSX.Element;
+declare function LabSidebarRegion({ contributions }: LabRegionProps): react.JSX.Element;
 /** The lab's aside sections, on the far side of the workspace from the sidebar.
  *  Fold state persists the way the sidebar's does. */
-declare function LabAsideRegion({ contributions }: LabRegionProps): react_jsx_runtime.JSX.Element;
+declare function LabAsideRegion({ contributions }: LabRegionProps): react.JSX.Element;
 /** The lab's readouts, in the shell footer below the workspace. */
-declare function LabFooterRegion({ contributions }: LabRegionProps): react_jsx_runtime.JSX.Element;
+declare function LabFooterRegion({ contributions }: LabRegionProps): react.JSX.Element;
 
 /**
  * Concatenate contribution bundles into one list, preserving order — order
@@ -183,7 +182,7 @@ interface PaletteRegionProps<TCtx extends ToolSlotContext = TrialChromeContext>
 /** A tool strip: a trial's, or the lab's. Selection lives in whichever tool
  *  slot the context carries; this region only reflects it. An item carrying
  *  `onActivate` is a command instead — it presses, and never latches. */
-declare function PaletteRegion<TCtx extends ToolSlotContext = TrialChromeContext>({ contributions, ctx, region, }: PaletteRegionProps<TCtx>): react_jsx_runtime.JSX.Element | null;
+declare function PaletteRegion<TCtx extends ToolSlotContext = TrialChromeContext>({ contributions, ctx, region, }: PaletteRegionProps<TCtx>): react.JSX.Element | null;
 
 /** Props for `<SidebarRegion>`. */
 interface SidebarRegionProps<TCtx extends SidebarSlotContext = TrialChromeContext> {
@@ -196,7 +195,7 @@ interface SidebarRegionProps<TCtx extends SidebarSlotContext = TrialChromeContex
  *  trial's, or the lab's. A section the trial has torn out is not rendered
  *  here — `Trial` portals its body into the workspace instead. A context with
  *  no `undockPanel` offers no tear-out. */
-declare function SidebarRegion<TCtx extends SidebarSlotContext = TrialChromeContext>({ contributions, ctx, region, }: SidebarRegionProps<TCtx>): react_jsx_runtime.JSX.Element | null;
+declare function SidebarRegion<TCtx extends SidebarSlotContext = TrialChromeContext>({ contributions, ctx, region, }: SidebarRegionProps<TCtx>): react.JSX.Element | null;
 
 /** Props for `<StatusRegion>`. */
 interface StatusRegionProps<TCtx = TrialChromeContext> {
@@ -206,7 +205,7 @@ interface StatusRegionProps<TCtx = TrialChromeContext> {
     region?: string;
 }
 /** Lays a bar's readouts out. */
-declare function StatusRegion<TCtx = TrialChromeContext>({ contributions, ctx, region, }: StatusRegionProps<TCtx>): react_jsx_runtime.JSX.Element | null;
+declare function StatusRegion<TCtx = TrialChromeContext>({ contributions, ctx, region, }: StatusRegionProps<TCtx>): react.JSX.Element | null;
 
 /** Which end of the title bar a `<TitleBarRegion>` lays out: `'lead'` renders
  *  the contributions that leave `end` unset, before the title; `'actions'`
@@ -220,7 +219,7 @@ interface TitleBarRegionProps {
     placement?: TitleBarPlacement;
 }
 /** Lays a trial's `titlebar` contributions out at one end of the bar. */
-declare function TitleBarRegion({ contributions, ctx, placement }: TitleBarRegionProps): react_jsx_runtime.JSX.Element | null;
+declare function TitleBarRegion({ contributions, ctx, placement }: TitleBarRegionProps): react.JSX.Element | null;
 
 /** Props for `<ToolbarRegion>`. */
 interface ToolbarRegionProps<TCtx = TrialChromeContext> {
@@ -232,7 +231,7 @@ interface ToolbarRegionProps<TCtx = TrialChromeContext> {
     label?: string;
 }
 /** Lays a bar's contributions out, grouped by their `group`. */
-declare function ToolbarRegion<TCtx = TrialChromeContext>({ contributions, ctx, region, label, }: ToolbarRegionProps<TCtx>): react_jsx_runtime.JSX.Element | null;
+declare function ToolbarRegion<TCtx = TrialChromeContext>({ contributions, ctx, region, label, }: ToolbarRegionProps<TCtx>): react.JSX.Element | null;
 
 /** Props for `<ViewportRegion>`. */
 interface ViewportRegionProps {
@@ -243,7 +242,7 @@ interface ViewportRegionProps {
  * Controls acting on the view of a trial. Anchored inside the content well
  * rather than in the toolbar, which acts on the trial itself.
  */
-declare function ViewportRegion({ contributions, ctx }: ViewportRegionProps): react_jsx_runtime.JSX.Element | null;
+declare function ViewportRegion({ contributions, ctx }: ViewportRegionProps): react.JSX.Element | null;
 
 export { resetTrial as B, suppressContributions as C, toolContributions as D, useLabChromeContext as E, useLabContext as F, PaletteRegion as P, SidebarRegion as S, ViewportRegion as V, LabAsideRegion as a, LabContext as c, LabFooterRegion as e, LabHeaderRegion as f, LabSidebarRegion as i, StatusRegion as l, TitleBarRegion as n, ToolbarRegion as p, addTrial as s, builtinContributions as t, cloneTrial as u, closeTrial as v, contributionsIn as w, labContributions as x, mergeContributions as y, reorderTrials as z };
 export type { AddTrialOptions as A, LabContribution as L, TitleBarPlacement as T, LabChromeContext as b, LabContextValue as d, LabRegion as g, LabRegionProps as h, PaletteRegionProps as j, SidebarRegionProps as k, StatusRegionProps as m, TitleBarRegionProps as o, ToolbarRegionProps as q, ViewportRegionProps as r };

package/dist/_dts/{types-B7y8hX1D.d.ts → types-CRPSGFAp.d.ts}

@@ -1,5 +1,6 @@
-import { ToolPrefNumberFormat, ToolPrefNumberUnit, ToolPrefLeaf, ToolPrefGroup } from '@weasel-js/core';
-import { P as PrefRenderer } from './PrefsRow.d-DFpPIeIC.js';
+import { D as Display, P as PrefRenderer } from './PrefsRow.d-TOZ7BgD9.js';
+import { ReactNode } from 'react';
+import { ToolPrefNumberUnit, ToolPrefLeaf, ToolPrefGroup } from '@weasel-js/core';
 
 /**
  * Renders the control cell for one config leaf. Identical to weasel-ui's
@@ -11,6 +12,9 @@ type ControlRenderer = PrefRenderer;
 interface ConfigOption {
     value: string;
     label: string;
+    /** A glyph in weasel-ui's icon set (`IconName`). A segmented row draws it in
+     *  place of `label`, which stays the accessible name and becomes the tooltip. */
+    icon?: string;
 }
 /** Everything a leaf can carry beyond its kind and default. A flat union of
  *  every `Pref*` leaf's extras, plus labkit's own `debounceMs`. */
@@ -24,8 +28,8 @@ interface Annotations {
     max?: number;
     step?: number;
     suffix?: string;
-    /** How a number's value is shown. `compact` abbreviates from a thousand up. */
-    format?: ToolPrefNumberFormat;
+    /** How a number's value shows, speaks and reads back — `compact()` reads `2.00M`. */
+    display?: Display;
     /** Display-unit conversion for a number stored in a canonical unit — the
      *  value, its bounds and its step all convert at the control's edge. */
     unit?: ToolPrefNumberUnit;
@@ -94,6 +98,24 @@ interface ResolvedConfig {
     showIf: ReadonlyMap<string, (config: Record<string, unknown>) => boolean>;
     /** Node-level `.render` overrides, keyed by path. */
     renderers: Readonly<Record<string, ControlRenderer>>;
+    /** Node-level `.dialog` rows, keyed by path. */
+    dialogs: Readonly<Record<string, DialogSpec>>;
+    /** Paths of the groups marked `.resettable()`, whose heading carries a
+     *  button that puts every value beneath it back to its default. */
+    resettable?: ReadonlySet<string>;
+}
+/** Options for a row drawn as a button that opens a dialog. */
+interface InDialogOptions {
+    /** What the row's button shows of the value. Defaults to a list joined with
+     *  commas, or the value itself. */
+    summary?: (value: unknown) => ReactNode;
+    /** The dialog's heading. Defaults to the row's label. */
+    title?: ReactNode;
+}
+/** A `.dialog` row: `body` is the dialog's content, handed the context a row
+ *  renderer gets. */
+interface DialogSpec extends InDialogOptions {
+    body: ControlRenderer;
 }
 /** How a node names the section it belongs to: the heading, and how that
  *  section opens. Every node in one section repeats the heading; only one of
@@ -109,6 +131,9 @@ interface SectionOption {
 /** Per-node extras that do not belong on a `PrefLeaf`. */
 interface NodeOptions extends BranchOptions {
     render?: ControlRenderer;
+    /** Draw the row as a button that opens a dialog. Set by `.dialog`; the
+     *  config entry records it, and `ControlPanel` draws it. */
+    dialog?: DialogSpec;
     /** Errors for this leaf under `config`, the instrument's whole config. */
     validate?: (leaf: ToolPrefLeaf, config: Record<string, unknown>) => string[];
     /** Computes this leaf's value while it is auto. Attaching one is what gives
@@ -128,6 +153,9 @@ interface BranchOptions {
     /** Show this node only while the predicate holds. On a group it hides the
      *  whole subtree; the values stay in config either way. */
     showIf?: (config: Record<string, unknown>) => boolean;
+    /** Put a button on this group's heading that returns every value beneath it
+     *  to its default. Groups only. */
+    resettable?: boolean;
 }
 /** A group's own annotations: what it is called and, optionally, why. */
 interface BranchAnnotations {
@@ -250,4 +278,4 @@ interface ColorField extends ConfigFieldBase {
  *  panel renders, and what `validateConfigSchema` checks. */
 type ConfigField = SliderField | CheckboxField | SelectField | NumberField | TextField | ColorField;
 
-export type { Annotations as A, BranchAnnotations as B, ControlRenderer as C, EntryValue as E, InferConfig as I, LeafPatch as L, NodeOptions as N, ResolvedConfig as R, SectionSpec as S, TextField as T, ValueAtPath as V, ConfigPath as a, ConfigField as b, ConfigSchema as c, ConfigRule as d, BranchOptions as e, CheckboxField as f, ColorField as g, ConfigBranch as h, ConfigEntry as i, ConfigFieldBase as j, ConfigFieldType as k, ConfigNode as l, ConfigOf as m, ConfigOption as n, ConfigRuleContext as o, ConfigShape as p, NodeValue as q, NumberField as r, SelectField as s, SelectOption as t, SliderField as u, SectionOption as v };
+export type { Annotations as A, BranchAnnotations as B, ConfigPath as C, DialogSpec as D, EntryValue as E, InDialogOptions as I, LeafPatch as L, NodeOptions as N, ResolvedConfig as R, SectionOption as S, TextField as T, ValueAtPath as V, ConfigField as a, ConfigSchema as b, ConfigRule as c, ControlRenderer as d, BranchOptions as e, CheckboxField as f, ColorField as g, ConfigBranch as h, ConfigEntry as i, ConfigFieldBase as j, ConfigFieldType as k, ConfigNode as l, ConfigOf as m, ConfigOption as n, ConfigRuleContext as o, ConfigShape as p, InferConfig as q, NodeValue as r, NumberField as s, SectionSpec as t, SelectField as u, SelectOption as v, SliderField as w };