@bitcobblers/wod-wiki-ui 0.10.42 → 0.35.2115

package/dist/index.d.cts

@@ -1,10 +1,12 @@
-import { Q as QueryExecutor } from './index-CTQ7Hrsa.cjs';
-export { B as ButtonAction, C as CursorFocusState, D as DefaultFrontmatterWidget, E as EditorDialect, a as EditorPresetOptions, b as EditorSection, c as EditorSectionSubtype, d as EditorSectionType, e as EmbedType, G as GeometryListener, N as NavigationHook, O as OverlayAction, f as QueryBlockPreviewOptions, R as RuntimePanelEntry, S as SectionRect, g as SectionState, W as WidgetConfig, h as WidgetProps, i as WidgetRegistry, j as activeCursorSection, k as addRuntimePanel, l as blockContentId, m as configureOverlayActions, n as cursorFocusExtension, o as dispatchAddRuntimePanel, p as dispatchExpandRuntimePanel, q as dispatchGutterHighlights, r as dispatchRemoveRuntimePanel, s as editingWidgetsField, t as editorPreset, u as editorTheme, v as embedPreviewDecorations, w as expandRuntimePanel, x as fenceCompletion, y as findQueryBlockSection, z as findWorkoutErrors, A as forceSectionParse, F as frontmatterPreview, H as frontmatterPreviewField, I as getCursorFocusState, J as getOverlayActions, K as gutterHighlightsField, L as gutterUnified, M as handleFenceAutoWrap, P as inlineButtonDecoration, T as lineIdsExtension, U as linkOpen, V as markdownSyntaxHiding, X as markdownTablePreview, Y as navigationFacet, Z as previewDecorations, _ as queryBlockPreview, $ as removeRuntimePanel, a0 as runtimePanelField, a1 as saveBlockQuerySource, a2 as sectionAtPos, a3 as sectionField, a4 as sectionGeometry, a5 as sessionQueryInsert, a6 as sessionQueryWql, a7 as setGutterHighlights, a8 as smartIncrement, a9 as toggleWidgetEdit, aa as urlAtPos, ab as widgetBlockPreview, ac as wodAutoWrap, ad as wodAutocompletion, ae as wodEditorKeymap, af as wodLinter, ag as wodOverlayPanel, ah as workoutLintSource, ai as wrapInTimeFence } from './index-CTQ7Hrsa.cjs';
+import { Q as QueryExecutor } from './index-DMTXLSJ0.cjs';
+export { B as ButtonAction, C as CursorFocusState, a as CustomCompletionSource, D as DefaultFrontmatterWidget, E as EditorDialect, b as EditorPresetOptions, c as EditorSection, d as EditorSectionSubtype, e as EditorSectionType, f as EmbedType, F as FrontmatterSuggestionCatalog, G as GeometryListener, N as NavigationHook, O as OverlayAction, g as QueryBlockPreviewOptions, R as RuntimePanelEntry, S as SectionRect, h as SectionState, W as WidgetConfig, i as WidgetProps, j as WidgetRegistry, k as activeCursorSection, l as addRuntimePanel, m as configureOverlayActions, n as cursorFocusExtension, o as dispatchAddRuntimePanel, p as dispatchExpandRuntimePanel, q as dispatchGutterHighlights, r as dispatchRemoveRuntimePanel, s as editingWidgetsField, t as editorPreset, u as editorTheme, v as embedPreviewDecorations, w as expandRuntimePanel, x as fenceCompletion, y as findQueryBlockSection, z as findWorkoutErrors, A as forceSectionParse, H as frontmatterPreview, I as frontmatterPreviewField, J as frontmatterSuggestions, K as frontmatterVisibility, L as getCursorFocusState, M as getOverlayActions, P as gutterHighlightsField, T as gutterUnified, U as handleFenceAutoWrap, V as inlineButtonDecoration, X as lineIdsExtension, Y as linkOpen, Z as linkPreview, _ as markdownSyntaxHiding, $ as markdownTablePreview, a0 as navigationFacet, a1 as previewDecorations, a2 as queryBlockPreview, a3 as registerCustomCompletionSource, a4 as removeRuntimePanel, a5 as runtimePanelField, a6 as saveBlockQuerySource, a7 as sectionAtPos, a8 as sectionField, a9 as sectionGeometry, aa as sessionQueryInsert, ab as sessionQueryWql, ac as setGutterHighlights, ad as smartIncrement, ae as toggleWidgetEdit, af as unregisterCustomCompletionSource, ag as urlAtPos, ah as widgetBlockPreview, ai as wodAutoWrap, aj as wodAutocompletion, ak as wodEditorKeymap, al as wodLinter, am as wodOverlayPanel, an as workoutLintSource, ao as wrapInTimeFence } from './index-DMTXLSJ0.cjs';
 import * as react from 'react';
-import { ReactNode, ComponentType } from 'react';
-import { QueryResult, DashboardToken, DashboardDocument, DashboardWidget, Series, RowsQueryResult, RowsRun, AnyParsedQuery, FindQueryResult, ParsedAggregateQuery, ParsedFindQuery } from '@bitcobblers/wod-wiki-wql';
-export { FindOptions, FindQueryResult, ParsedAggregateQuery, ParsedFindQuery, ParsedRowsQuery, QueryOptions, QueryResult, RowsQueryResult, RowsRun } from '@bitcobblers/wod-wiki-wql';
-import { Segment, UnifiedEventRecord, BlockIndexRow } from '@bitcobblers/wod-wiki-core';
+import react__default, { ReactNode, ComponentType } from 'react';
+import { QueryResult, DashboardToken, DashboardDocument, DashboardWidget, Series, RowsQueryResult, RowsRun, AnyParsedQuery, FindQueryResult, ParsedAggregateQuery, ParsedFindQuery, ParsedPipelineQuery } from '@bitcobblers/wod-wiki-wql';
+export { CONTENT_GROUPING_DIMENSIONS, FindOptions, FindQueryResult, ParsedAggregateQuery, ParsedFindQuery, ParsedPipelineQuery, ParsedRowsQuery, PipelineResult, QueryOptions, QueryResult, RowsQueryResult, RowsRun } from '@bitcobblers/wod-wiki-wql';
+import { IMetric, EventRecord, BlockIndexRow } from '@bitcobblers/wod-wiki-core';
+export { blockContentId } from '@bitcobblers/wod-wiki-core';
+import { MetricPresentationToken } from '@bitcobblers/wod-wiki-lang';
 import { ClassValue } from 'clsx';
 import '@codemirror/state';
 import '@codemirror/view';
@@ -20,13 +22,46 @@ interface StorageLike {
 declare const CODEMIRROR_SINGLETON_DEPS: readonly ["@codemirror/autocomplete", "@codemirror/commands", "@codemirror/lang-markdown", "@codemirror/language", "@codemirror/lint", "@codemirror/search", "@codemirror/state", "@codemirror/theme-one-dark", "@codemirror/view", "@lezer/common", "@lezer/highlight", "@lezer/lr", "@lezer/markdown"];
 
 interface WidgetFrameProps {
+    /** DOM anchor for the frame (e.g. `widget-<key>`) — L3 indexes scroll here. */
+    id?: string;
     title: string;
     question: string;
-    query: string;
+    /** Raw WQL for the widget. Hidden by default — only rendered with showQuery. */
+    query?: string;
     span?: string;
+    /** Show the raw WQL query box (teaching/authoring surfaces). View-first default hides it. */
+    showQuery?: boolean;
+    /**
+     * Read-only inspection affordance — an always-visible button (prebuilt
+     * seeds, teaching surfaces) opening the host's query inspector. Distinct
+     * from editing: present without a toolbar.
+     */
+    onInspect?: () => void;
+    /** Always-visible affordance: open this widget's resolved query in the
+     * WQL explorer (host navigates). */
+    onOpenInExplorer?: () => void;
+    /**
+     * Edit-mode action cluster (edit / duplicate / remove / reorder / size),
+     * rendered top-right and always visible while present. The host builds it;
+     * the frame only positions it.
+     */
+    toolbar?: ReactNode;
     children: ReactNode;
 }
-declare function WidgetFrame({ title, question, query, span, children }: WidgetFrameProps): react.JSX.Element;
+declare function WidgetFrame({ id, title, question, query, span, showQuery, onInspect, onOpenInExplorer, toolbar, children }: WidgetFrameProps): react.JSX.Element;
+/** Standard edit-mode tool-button chrome for the widget toolbar. */
+declare function WidgetToolButton({ label, onClick, disabled, active, children, }: {
+    label: string;
+    onClick: () => void;
+    disabled?: boolean;
+    active?: boolean;
+    children: ReactNode;
+}): react.JSX.Element;
+/** The primary "open the full editor" affordance inside the toolbar. */
+declare function WidgetEditButton({ title, onClick }: {
+    title: string;
+    onClick: () => void;
+}): react.JSX.Element;
 
 interface QueryValueProps {
     result: QueryResult;
@@ -66,20 +101,27 @@ interface WidgetChartProps {
     unit?: string;
     /** Positional widget parameters from the block body (e.g. goal target or zone targets). */
     params?: string[];
+    /** Fence-tag presentation attributes (decision 22) — preferred over legacy positional params. */
+    attributes?: Record<string, string>;
 }
-declare function WidgetChart({ type, result, label, unit, params }: WidgetChartProps): react.JSX.Element;
+declare function WidgetChart({ type, result, label, unit, params, attributes }: WidgetChartProps): react__default.JSX.Element;
 declare function WidgetProblemBadge({ message }: {
     message: string;
-}): react.JSX.Element;
+}): react__default.JSX.Element;
 declare function ProposedMetricBadge({ metric }: {
     metric: string;
-}): react.JSX.Element;
+}): react__default.JSX.Element;
 
 interface DashboardTokenControlsProps {
     tokens: DashboardToken[];
     /** Current value per token name (defaults applied by the caller). */
     values: Record<string, string>;
-    /** Present when the note is editable — changes write back to frontmatter. */
+    /**
+     * Present when the note is editable — a change commits exactly once, on an
+     * explicit action: a list-token segment click, or a scalar-token blur /
+     * Enter. Keystrokes only edit the local draft — they never rewrite the
+     * note or re-run widgets mid-edit.
+     */
     onChange?: (name: string, value: string) => void;
 }
 /**
@@ -90,19 +132,50 @@ interface DashboardTokenControlsProps {
  */
 declare function DashboardTokenControls({ tokens, values, onChange }: DashboardTokenControlsProps): react.JSX.Element | null;
 
+/** A widget's grid placement — column span 1..4, or a forced full row. */
+interface WidgetSpanOption {
+    spanCols?: number;
+    spanFull?: boolean;
+}
+/** A note heading rendered as a full-width grid row between widgets, with its
+ * own DOM anchor (L3 scroll target). Order within `headings` is preserved. */
+interface DashboardHeadingAnchor {
+    id: string;
+    /** Markdown heading level (2+; level 1 renders as the page title surface). */
+    level: number;
+    text: string;
+    /** Insert before this widget index; `widgets.length` = after the last. */
+    beforeWidget: number;
+}
 interface DashboardViewProps {
     /** Parsed dashboard note (buildDashboardDocument). */
     document: DashboardDocument;
+    /** Note headings to render between the widgets (document order). */
+    headings?: DashboardHeadingAnchor[];
     /** Injected QueryExecutor for executing WQL queries. Zero singleton coupling. */
     executor?: QueryExecutor;
     /** Optional rollup fact warmer callback. */
     onEnsureRollupFacts?: () => Promise<void>;
     /** Current token values; defaults to each token's declared default. */
     tokenValues?: Record<string, string>;
-    /** Present when the note is editable — control changes write back to frontmatter. */
+    /** Present when the note is editable — committed control changes write back to frontmatter. */
     onTokenChange?: (name: string, value: string) => void;
-    /** Present when the host offers query editing (composer modal owned by the host). */
-    onEditQuery?: (widget: DashboardWidget) => void;
+    /**
+     * Edit mode: per-widget arrangement chrome (edit / duplicate / remove /
+     * reorder / size) renders on every card. View mode stays chrome-free —
+     * the host gates editing on this flag plus the handler set below.
+     */
+    editMode?: boolean;
+    /** Open the shared authoring composer for this widget (edit flow). */
+    onEditWidget?: (widget: DashboardWidget) => void;
+    /** Read-only query inspection (prebuilt seeds, teaching surfaces). */
+    onInspectWidget?: (widget: DashboardWidget) => void;
+    /** Open the widget's token-resolved query in the WQL explorer (host navigates). */
+    onOpenInExplorer?: (widget: DashboardWidget, query: string) => void;
+    onDuplicateWidget?: (widget: DashboardWidget) => void;
+    onRemoveWidget?: (widget: DashboardWidget) => void;
+    onMoveWidget?: (widget: DashboardWidget, delta: -1 | 1) => void;
+    onResizeWidget?: (widget: DashboardWidget, span: WidgetSpanOption) => void;
     /** Optional execution range (ms epoch). Omit to use each query's own window. */
     rangeStart?: number;
     rangeEnd?: number;
@@ -112,15 +185,19 @@ interface DashboardViewProps {
  * DashboardView — the state-free dashboard renderer (#900, format locked in #899).
  *
  * Takes a parsed DashboardDocument + current token values, runs all widget
- * queries concurrently via the injected QueryExecutor, and renders the responsive CSS grid.
+ * queries concurrently via the injected QueryExecutor, and renders the
+ * responsive CSS grid. All authoring interactions are host-owned: the view
+ * surfaces the affordances (edit-mode toolbar, inspect button) and reports
+ * through the injected callbacks — it never owns dialog or write state.
  */
-declare function DashboardView({ document, executor, onEnsureRollupFacts, tokenValues, onTokenChange, onEditQuery, rangeStart, rangeEnd, preferredUnit, }: DashboardViewProps): react.JSX.Element;
+declare function DashboardView({ document, headings, executor, onEnsureRollupFacts, tokenValues, onTokenChange, editMode, onEditWidget, onInspectWidget, onOpenInExplorer, onDuplicateWidget, onRemoveWidget, onMoveWidget, onResizeWidget, rangeStart, rangeEnd, preferredUnit, }: DashboardViewProps): react.JSX.Element;
 
 interface WqlEmptyStateProps {
-    result: QueryResult | undefined;
+    result?: QueryResult | undefined;
     className?: string;
+    actions?: ReactNode;
 }
-declare function WqlEmptyState({ result, className }: WqlEmptyStateProps): react.JSX.Element | null;
+declare function WqlEmptyState({ result, className, actions }: WqlEmptyStateProps): react.JSX.Element | null;
 
 interface TopListProps {
     result: QueryResult;
@@ -141,14 +218,18 @@ interface GoalRingsProps {
     label?: string;
     unit?: string;
 }
-declare function GoalRings({ result, params, label, unit }: GoalRingsProps): react.JSX.Element;
+declare function GoalRings({ result, attributes, params, label, unit }: GoalRingsProps & {
+    attributes?: Record<string, string>;
+}): react.JSX.Element;
 
 interface ZoneDistributionProps {
     result: QueryResult | undefined;
     params?: string[];
     unit?: string;
 }
-declare function ZoneDistribution({ result, params }: ZoneDistributionProps): react.JSX.Element;
+declare function ZoneDistribution({ result, params, attributes }: ZoneDistributionProps & {
+    attributes?: Record<string, string>;
+}): react.JSX.Element;
 
 type AnalyticsRangeWeeks = 4 | 8 | 16;
 interface RangeSelectorProps {
@@ -220,14 +301,82 @@ interface AnalyticsUnitPreferenceProps {
 }
 declare function AnalyticsUnitPreference({ className, unit: unitProp, forced, storage }: AnalyticsUnitPreferenceProps): react.JSX.Element;
 
+declare function formatMMSS(ms: number): string;
+declare function formatClockTime(d: Date): string;
+declare const TONE_CLASS: Record<string, string>;
+declare function MetricBadge({ token }: {
+    token: MetricPresentationToken;
+}): react.JSX.Element | null;
+/** Metric badges for a statement/output metric group. */
+declare function presentBadges(metrics: Iterable<IMetric>): ReactNode;
+declare const OUTPUT_TYPE_CLASS: Record<string, string>;
+declare const OUTPUT_TYPE_DOT: Record<string, string>;
+interface CategorizedMetrics {
+    efforts: IMetric[];
+    reps: IMetric[];
+    loads: IMetric[];
+    rounds: IMetric[];
+    durations: IMetric[];
+    distances: IMetric[];
+    hints: IMetric[];
+}
+declare function extractMetricsByCategory(metrics?: Iterable<IMetric>): CategorizedMetrics;
+interface OutputFilterPreset {
+    label: string;
+    query: string;
+}
+type OutputFilterInput = string | OutputFilterPreset;
+/** Default row filter — segment statements only (the Workbench default). */
+declare const DEFAULT_PRIMARY_FILTER = "type:segment";
+declare const DEFAULT_OUTPUT_FILTERS: OutputFilterPreset[];
+declare function normalizeOutputFilter(filter: OutputFilterInput): OutputFilterPreset;
+/** Structural subset satisfied by live `IOutputStatement`s, stored statements,
+ *  and `EventRecord` event rows alike. */
+interface OutputStatementRow {
+    readonly id?: number | string;
+    readonly outputType?: string;
+    readonly timeSpan?: {
+        started: number;
+        ended?: number;
+    };
+    readonly metrics?: Iterable<IMetric>;
+    readonly sourceBlockKey?: string;
+    readonly completionReason?: string;
+}
+declare function OutputFilterPills({ presets, filter, onChange, }: {
+    presets: OutputFilterPreset[];
+    filter: string;
+    onChange: (next: string) => void;
+}): react.JSX.Element;
+interface OutputStatementsTableProps {
+    outputs: readonly OutputStatementRow[];
+    /** Filter expression (`type:segment`, free text). Empty shows all. */
+    filter?: string;
+    /** Epoch ms the +offset column is relative to. Defaults to first statement start. */
+    timeOrigin?: number;
+    /** Clears the active filter — enables the Card List's Clear-filter
+     *  affordance on the filtered-empty state. Optional; hosts without a
+     *  clearable filter omit it. */
+    onClearFilter?: () => void;
+}
+/** The Session Results surface — Card List below `sm`, the 9-column table at
+ *  `sm` and above. One component: same props, same filtering; hosts (analytics
+ *  explorer, editor query blocks, workbench) inherit the phone path. */
+declare function OutputStatementsTable({ outputs, filter, timeOrigin, onClearFilter, }: OutputStatementsTableProps): react.JSX.Element;
+
 interface RowsTableProps {
     result: RowsQueryResult;
     /** Optional per-run chrome rendered inside the section header (#948 RPE). */
     renderRunHeaderExtra?: (run: RowsRun) => ReactNode;
-    /** Optional segment grid renderer (e.g. app's ReviewGrid). Default: clean plain table rows. */
-    renderSegments?: (segments: Segment[], run: RowsRun) => ReactNode;
+    /** Filter presets for the pills row (defaults to All/Segments/Events). */
+    presets?: OutputFilterInput[];
+    /** Controlled filter expression — omit to let the table own its filter state. */
+    filter?: string;
+    onFilterChange?: (filter: string) => void;
 }
-declare function RowsTable({ result, renderRunHeaderExtra, renderSegments, }: RowsTableProps): react.JSX.Element;
+/** The Session Results Table — renders a Rows Query result: one section per
+ *  run, filter pills on top, and the shared statement table as the body. */
+declare function RowsTable({ result, renderRunHeaderExtra, presets, filter, onFilterChange, }: RowsTableProps): react.JSX.Element;
 
 interface QueryBlockViewProps {
     /** Raw text between the ```query fences — the WQL query string or block source. */
@@ -236,8 +385,10 @@ interface QueryBlockViewProps {
     executor?: QueryExecutor;
     /** Optional callback or subscription hook for when a result is saved, replacing hardcoded resultRecorder coupling. */
     onResultSaved?: (callback: () => void) => (() => void) | void;
-    /** Present when the query block is editable — opens the WQL composer. */
-    onSaveQuery?: (nextQuery: string) => void;
+    /** Present when the query block is editable — opens the WQL composer.
+     *  May return the write's Promise so a rejected save keeps the editor
+     *  open; a plain void write is fire-and-forget. */
+    onSaveQuery?: (nextQuery: string) => void | Promise<void>;
     /** When multiple queries appear in one block, the index of this query. */
     queryIndex?: number;
     /** When true, editing the query is disallowed. */
@@ -248,14 +399,26 @@ interface QueryBlockViewProps {
     widgetError?: string;
     /** Token values from the note's frontmatter, for `$token` substitution. */
     tokenValues?: Record<string, string>;
+    /** Fence-tag presentation attributes (decision 22). */
+    attributes?: Record<string, string>;
     /** Optional RPE capture handler. */
     onCaptureRpe?: (resultId: string, rpe: number) => Promise<void>;
-    /** Optional custom segment grid renderer. */
-    renderSegments?: (segments: Segment[], run: RowsRun) => React.ReactNode;
-}
-declare function QueryBlockView({ query, executor, onResultSaved, onSaveQuery, queryIndex: _queryIndex, readOnly, widgetType, widgetError, tokenValues, onCaptureRpe, renderSegments, }: QueryBlockViewProps): react.JSX.Element;
-
-declare function readSessionRpe(events: UnifiedEventRecord[] | undefined): number | undefined;
+    /** Optional click handler for opening a note from :note results. */
+    onOpenNote?: (item: {
+        id: string;
+        title?: string;
+        blockContentId?: string;
+    }) => void;
+    /** Optional resolver returning the destination href for an item in :note results. */
+    noteHref?: (item: {
+        id: string;
+        title?: string;
+        blockContentId?: string;
+    }) => string;
+}
+declare function QueryBlockView({ query, executor, onResultSaved, onSaveQuery, queryIndex: _queryIndex, readOnly, widgetType, widgetError, tokenValues, attributes, onCaptureRpe, onOpenNote, noteHref, }: QueryBlockViewProps): react.JSX.Element;
+
+declare function readSessionRpe(events: EventRecord[] | undefined): number | undefined;
 interface RowsResultsChromeProps {
     /** The session result id from the written `rows:{result:…}` query. */
     resultId: string;
@@ -267,21 +430,23 @@ interface RowsResultsChromeProps {
     onCaptureRpe?: (resultId: string, rpe: number) => Promise<void>;
     /** Re-run the parent query after a capture so the grid reflects the RPE. */
     onCaptured?: () => void;
-    /** Optional segment grid renderer. */
-    renderSegments?: (segments: Segment[], run: RowsRun) => React.ReactNode;
 }
-declare function RowsResultsChrome({ resultId, sessionResult, executor, onCaptureRpe, onCaptured, renderSegments, }: RowsResultsChromeProps): react.JSX.Element;
+declare function RowsResultsChrome({ resultId, sessionResult, executor, onCaptureRpe, onCaptured, }: RowsResultsChromeProps): react.JSX.Element;
 
 interface WqlQueryInspectorModalProps {
     isOpen: boolean;
     onClose: () => void;
     initialQuery: string;
-    onApply: (newQuery: string) => void;
+    /** Persist the applied query. A returned Promise gates the button until
+     *  it settles; a rejection keeps the dialog open with the error visible. */
+    onApply: (newQuery: string) => void | Promise<void>;
     title?: string;
     subtitle?: string;
+    /** Label for the confirm button (defaults to "Apply to Block"). */
+    applyLabel?: string;
     executor?: QueryExecutor;
 }
-declare function WqlQueryInspectorModal({ isOpen, onClose, initialQuery, onApply, title, subtitle, executor, }: WqlQueryInspectorModalProps): react.JSX.Element | null;
+declare function WqlQueryInspectorModal({ isOpen, onClose, initialQuery, onApply, title, subtitle, applyLabel, executor, }: WqlQueryInspectorModalProps): react.JSX.Element;
 
 type WqlExecutor = (ast: AnyParsedQuery) => Promise<FindQueryResult | QueryResult>;
 type WqlStageCounts = {
@@ -299,22 +464,25 @@ declare const DEFAULT_DIAGNOSTICS_DEBOUNCE_MS = 150;
 declare function useWqlStageCounts(ast: AnyParsedQuery, valid: boolean, execute: WqlExecutor | undefined, debounceMs?: number): WqlStageCounts | undefined;
 
 /**
- * Shared query-clause model + WQL compiler for the WqlComposer.
+ * The WqlComposer pill vocabulary — types, metadata, and option lists.
+ * Compilation and restore live in `./queryAst` (ticket 013): composer state
+ * is the C6 AST; strings are produced only through the engine serializer.
  *
- * Source-pivot model (issue #838, decision #836): a single `source` head
- * slot — journal | collections | feeds | notes | blocks | efforts | metrics —
- * pivots the query kind. Content sources compile the `find:` skeleton; `metrics`
- * compiles the aggregate skeleton (`agg:metric{filters} by {dims}.rollup(p)
- * [in unit] [where find:…]`). The find target and scope are derived from the
- * source value (the legacy `target`/`scope` clause types are retired).
+ * Canonical structure (work item 3): a query has a `kind` (find documents vs
+ * measure numbers), a singular `target` (colon `<target>` head), and an optional
+ * `source` storage scope (`Where stored` — WQL_SOURCE_VALUES; all sources =
+ * no source filter). Filter capability sets mirror what the QueryService
+ * executors actually apply — parser acceptance alone never advertises a
+ * clause (`has:` parses but no executor applies it, so it is not offered).
  *
  * Static option lists live here; dynamic typeahead data sources live in
  * ./suggestionSources (issue #831). All vocab is sourced from the canonical
- * modules (@bitcobblers/wod-wiki-engine) — never hardcoded in the composer (decision #824).
+ * modules (@bitcobblers/wod-wiki-wql) — never hardcoded in the composer (decision #824).
  *
  * Supports freeform token slots, placeholder guidance, and keyboard navigation.
  */
-type ClauseType = 'source' | 'text' | 'catalog' | 'tag' | 'effort' | 'discipline' | 'intensity' | 'origin' | 'type' | 'has' | 'time' | 'where' | 'agg' | 'metric' | 'groupby' | 'rollup' | 'unit' | 'result' | 'block' | 'note' | 'output';
+
+type ClauseType = 'kind' | 'target' | 'source' | 'text' | 'catalog' | 'tag' | 'effort' | 'domain' | 'format' | 'equipment' | 'quality' | 'intent' | 'discipline' | 'intensity' | 'origin' | 'type' | 'time' | 'where' | 'agg' | 'metric' | 'groupby' | 'rollup' | 'unit' | 'result' | 'block' | 'note' | 'page' | 'plane' | 'pipes';
 interface QueryClause {
     id: string;
     /** Built-in ClauseType or a custom slot type id from the ComposerRegistry. */
@@ -325,16 +493,39 @@ interface QueryClause {
     placeholder?: string;
     icon?: string;
     prefix?: string;
-}
-/** Content sources compile `find:note in <scope>`; notes/blocks use `all`. */
-declare const CONTENT_SOURCES: ("journal" | "collections" | "feeds" | "notes" | "blocks" | "efforts")[];
-/** The plane a source value belongs to — everything but `metrics` is content. */
-declare function sourcePlane(source: string): 'content' | 'metrics';
-declare const SOURCE_OPTIONS: {
+    /** Index into the parsed AST's global filters array (ast.filters[filterIndex])
+     *  — identifies one specific filter occurrence; editing one occurrence must
+     *  never merge or rewrite another. */
+    filterIndex?: number;
+    /** True when this filter occurrence is negated (`!key:value`). */
+    negate?: boolean;
+}
+/** Query shape: `find` compiles the colon `<target>` skeleton (`:note{…}`),
+ *  `aggregate` compiles `agg:metric{filters} by {dims}` and exposes agg/metric. */
+declare const KIND_OPTIONS: {
     value: string;
     label: string;
     description: string;
 }[];
+/** Singular find targets — the colon `<target>` head (C7 closed enum). */
+declare const TARGET_OPTIONS: {
+    value: "note" | "effort" | "segment" | "event" | "session" | "block";
+    label: string;
+    description: string;
+}[];
+/** Storage scopes — the `source:` filter values (`Where stored`). All
+ *  sources means no source filter at all. */
+declare const SOURCE_OPTIONS: {
+    value: "efforts" | "journal" | "feeds" | "guides" | "playground" | "dashboards";
+    label: string;
+    description: string;
+}[];
+/** Output-statement planes for `plane:` on `:session` (executor narrows
+ *  events by the promoted `outputType` column). */
+declare const PLANE_OPTIONS: {
+    value: "system" | "segment" | "completion" | "event" | "load" | "compiler" | "analytics" | "wellness";
+    label: "system" | "segment" | "completion" | "event" | "load" | "compiler" | "analytics" | "wellness";
+}[];
 declare const TIME_OPTIONS: {
     value: string;
     label: string;
@@ -344,17 +535,20 @@ declare const AGG_OPTIONS: {
     value: "max" | "min" | "sum" | "avg" | "count" | "last" | "delta";
     label: "max" | "min" | "sum" | "avg" | "count" | "last" | "delta";
 }[];
+/** Multi-unit bucket widths — parse accepts any `N>1` + d|w (single-unit
+ *  day/week grouping is `by {day}`/`by {week}`, never `.rollup(1w)`); the
+ *  list is common suggestions, typed widths are parser-validated. */
 declare const ROLLUP_OPTIONS: {
-    value: "1d" | "1w";
+    value: string;
     label: string;
 }[];
 declare const GROUPBY_OPTIONS: {
-    value: "result" | "day" | "origin" | "page" | "round" | "metric" | "note" | "week" | "effort" | "discipline" | "intensity" | "block" | "session" | "grain" | "tags";
-    label: "result" | "day" | "origin" | "page" | "round" | "metric" | "note" | "week" | "effort" | "discipline" | "intensity" | "block" | "session" | "grain" | "tags";
+    value: "format" | "origin" | "result" | "day" | "page" | "domain" | "round" | "metric" | "note" | "week" | "effort" | "intensity" | "session" | "equipment" | "quality" | "intent" | "discipline" | "block" | "grade" | "grain" | "tags";
+    label: "format" | "origin" | "result" | "day" | "page" | "domain" | "round" | "metric" | "note" | "week" | "effort" | "intensity" | "session" | "equipment" | "quality" | "intent" | "discipline" | "block" | "grade" | "grain" | "tags";
 }[];
 declare const METRIC_OPTIONS: {
-    value: "totalVolume" | "totalDistance" | "tis" | "sessionLoad" | "reps" | "distance" | "resistance" | "elapsed" | "power" | "pace" | "calc.metMinutes" | "calc.acwr" | "calc.monotony" | "calc.strain" | "calc.e1rm" | "calc.ctl" | "calc.atl" | "calc.tsb" | "calc.soreness" | "calc.sleep" | "calc.hrv" | "calc.readiness" | "calc.mvcBw" | "calc.ef" | "calc.adherence" | "calc.pct1rm" | "calc.sends";
-    label: "totalVolume" | "totalDistance" | "tis" | "sessionLoad" | "reps" | "distance" | "resistance" | "elapsed" | "power" | "pace" | "calc.metMinutes" | "calc.acwr" | "calc.monotony" | "calc.strain" | "calc.e1rm" | "calc.ctl" | "calc.atl" | "calc.tsb" | "calc.soreness" | "calc.sleep" | "calc.hrv" | "calc.readiness" | "calc.mvcBw" | "calc.ef" | "calc.adherence" | "calc.pct1rm" | "calc.sends";
+    value: "distance" | "resistance" | "elapsed" | "totalVolume" | "totalDistance" | "tis" | "sessionLoad" | "reps" | "power" | "pace" | "calc.metMinutes" | "calc.acwr" | "calc.monotony" | "calc.strain" | "calc.e1rm" | "calc.ctl" | "calc.atl" | "calc.tsb" | "calc.soreness" | "calc.sleep" | "calc.hrv" | "calc.readiness" | "calc.mvcBw" | "calc.ef" | "calc.adherence" | "calc.pct1rm" | "calc.sends";
+    label: "distance" | "resistance" | "elapsed" | "totalVolume" | "totalDistance" | "tis" | "sessionLoad" | "reps" | "power" | "pace" | "calc.metMinutes" | "calc.acwr" | "calc.monotony" | "calc.strain" | "calc.e1rm" | "calc.ctl" | "calc.atl" | "calc.tsb" | "calc.soreness" | "calc.sleep" | "calc.hrv" | "calc.readiness" | "calc.mvcBw" | "calc.ef" | "calc.adherence" | "calc.pct1rm" | "calc.sends";
 }[];
 declare const UNIT_OPTIONS: {
     value: "kg" | "lb";
@@ -367,7 +561,6 @@ declare const UNIT_OPTIONS: {
  */
 declare const WHERE_AGGREGATORS: readonly string[];
 declare const WHERE_METRICS: readonly string[];
-declare const WHERE_OPERATORS: readonly string[];
 interface ClauseMeta {
     label: string;
     inputType: 'radio' | 'freetext' | 'select';
@@ -385,109 +578,88 @@ declare const CLAUSE_META: Record<ClauseType, ClauseMeta>;
  * anything else gets a generic fallback so a stale clause still renders.
  */
 declare function getClauseMeta(type: string): ClauseMeta;
-/**
- * Maps a single clause to its WQL fragment syntax.
- */
-declare function clauseToWql(clause: QueryClause): {
-    key?: string;
-    filterStr?: string;
-};
-/**
- * Composes a full WQL string from an array of QueryClauses.
- *
- * Content planes: find:<target>{<filters>} in <scope> [last <n><unit>] [where <join>]
- *   — target/scope derived from `source` (journal|collections|feeds → note in
- *   <source>; notes → note in all; blocks → block in all; anything else →
- *   note in <verbatim value>, the salvage path for exotic scopes).
- * Metrics plane:   <agg>:<metric>{<filters>} [by {<dims>}] [.rollup(<p>)] [in <unit>] [where <find join>]
- */
-declare function clausesToWql(clauses: QueryClause[]): string;
-/**
- * Restore composer clauses from a WQL string — the inverse of
- * `clausesToWql`, used to hydrate composer state from the URL.
- *
- * Unlike `parseQuery`, this is a *salvage* parser: it mirrors the compiler's
- * structure on both planes without validating the fragments, so composer-
- * reachable states that are WQL-invalid (e.g. `text:hello world`, a `1m`
- * rollup period, an empty metric) still restore exactly — the diagnostics
- * strip then attributes the parse error to the offending slot.
- *
- * Returns null when the string cannot be a composer product: a negated
- * filter, or an unknown/custom-less filter key.
- */
-declare function wqlToClauses(wql: string): QueryClause[] | null;
-/**
- * Set the aggregate metric, re-basing the clause list on the metrics plane
- * when needed (sidebar / launcher flows, issue #839): content planes pivot
- * via `pivotClauses` (shared filters survive), a missing source or metric
- * clause is seeded, and the metric value lands on the first metric clause.
- */
-declare function setMetricClause(clauses: QueryClause[], metric: string): QueryClause[];
-/**
- * Re-base the clause list on a new source value (decision #836): shared
- * filter clauses survive the pivot; kind-specific clauses are dropped
- * (content plane: time/where and any metrics head; metrics plane: time/
- * where). Pivoting to metrics seeds the head slots (agg=sum, metric empty
- * for placeholder guidance).
- */
-declare function pivotClauses(clauses: QueryClause[], source: string): QueryClause[];
-declare function defaultClauses(): QueryClause[];
-/** Default clauses for aggregate/metrics queries (source=metrics, agg=sum, empty metric). */
-declare function defaultMetricsClauses(): QueryClause[];
-/**
- * Value of the first clause of `type`, trimmed, or `fallback` when absent or
- * empty. Mirrors the lookup/defaulting `clausesToWql` performs, so consumers
- * (e.g. the Library shelf) share one defaulting rule with the compiler.
- */
-declare function clauseValue(clauses: QueryClause[], type: string, fallback?: string): string;
 
 interface WqlValidationState {
-    /** True when the composed WQL parses without error. */
     valid: boolean;
-    /** Parser error message when invalid. */
     error?: string;
 }
 interface WqlComposerProps {
-    /** Seed clauses for uncontrolled usage. Defaults to source/time. */
-    initialClauses?: QueryClause[];
-    /** Controlled clauses. When provided, the component does not own clause state. */
-    clauses?: QueryClause[];
-    /** Fired whenever the clause list changes (add / edit / remove). */
-    onClausesChange?: (clauses: QueryClause[]) => void;
-    /** Fired (including on mount) with the composed WQL string. */
-    onWqlChange?: (wql: string) => void;
-    /** Fired (including on mount) with parse validation state. */
+    initialQuery?: string;
+    query?: string;
+    /** Synchronous resolved draft, including invalid exact text. Execution debounce belongs to the host. */
+    onQueryChange?: (wql: string) => void;
     onValidationChange?: (state: WqlValidationState) => void;
-    /** Fired (including on mount) with the parsed AST. */
     onAstChange?: (ast: AnyParsedQuery) => void;
-    /**
-     * Fired on Enter when no free text is pending — the run-on-submit signal
-     * for hosts like the analytics explorer. Receives the composed WQL.
-     */
+    /** Explicit actions receive the current valid draft on the first activation. */
     onSubmit?: (wql: string) => void;
-    /** Render the diagnostics strip (badge, AST summary, stage counts). Default true. */
+    actionLabel?: string;
+    compact?: boolean;
     showDiagnostics?: boolean;
-    /**
-     * Executor for live stage counts in the diagnostics strip.
-     */
+    diagnosticsPosition?: 'top' | 'bottom';
     execute?: WqlExecutor;
-    /** Debounce for live execution feedback. Default 150ms. */
+    /** Reuse host execution counts instead of running another query. */
+    stages?: WqlStageCounts;
     debounceMs?: number;
-    /** Extension point: extra content rendered inside the bar, after the free-text input. */
     customSlots?: ReactNode;
-    /** Host actions appended on the diagnostics line. */
     diagnosticsActions?: ReactNode;
-    /**
-     * Clause types kept in the model but NOT rendered as pills.
-     */
     hiddenClauseTypes?: ClauseType[];
-    /** Focus the free-text input on mount. */
+    /** Priority only; valid choices are never excluded by favorites. */
+    preferredChoices?: readonly string[];
     autoFocus?: boolean;
-    /** Free-text input placeholder. */
     placeholder?: string;
     className?: string;
 }
-declare function WqlComposer({ initialClauses, clauses: controlledClauses, onClausesChange, onWqlChange, onValidationChange, onAstChange, onSubmit, showDiagnostics, execute, debounceMs, customSlots, diagnosticsActions, hiddenClauseTypes, autoFocus, placeholder, className, }: WqlComposerProps): react.JSX.Element;
+declare function WqlComposer({ initialQuery, query, onQueryChange, onValidationChange, onAstChange, onSubmit, actionLabel, compact, showDiagnostics, diagnosticsPosition, execute, stages: suppliedStages, debounceMs, customSlots, diagnosticsActions, hiddenClauseTypes, preferredChoices, autoFocus, placeholder, className, }: WqlComposerProps): react.JSX.Element;
+
+/**
+ * filterTypeahead — matches free text typed into the WqlComposer's input
+ * against the filter-clause vocabulary (queryClauses). While the user types
+ * a filter key ('so', 'inten', 'eff'…) the composer proposes adding that
+ * filter — or, when a pill of that type is already on the query, editing it.
+ * Accept (Tab or tap) adds/activates the pill and opens its condition
+ * editor; the composer owns candidates (source-plane allowlist, existing
+ * pills, hidden types) and the accept behavior.
+ *
+ * Pure module: no React.
+ */
+interface FilterTypeaheadCandidate {
+    /** Clause type key, e.g. 'source' | 'effort' | 'catalog'. */
+    type: string;
+    label: string;
+    /** Placeholder describing the condition, e.g. 'journal, notes, metrics…'. */
+    hint: string;
+    icon: string;
+    /** True when a pill of this type is already on the query — accept edits it. */
+    present: boolean;
+    /** Index of the existing pill when `present`. */
+    pillIdx?: number;
+}
+interface FilterTypeaheadMatch extends FilterTypeaheadCandidate {
+}
+/**
+ * Match the typed text against candidate filter keys/labels: prefix match on
+ * the type key first, then the display label; shorter keys rank first within
+ * the same class. Mid-WQL text (whitespace, braces, or a `:` — the
+ * composer's query/raw/invalid pending paths own that) proposes nothing.
+ */
+declare function matchFilterTypeahead(freeText: string, candidates: FilterTypeaheadCandidate[]): FilterTypeaheadMatch[];
+
+interface TokenSlotPillProps {
+    clause: QueryClause;
+    isActive?: boolean;
+    invalid?: boolean;
+    invalidReason?: string;
+    onClick?: () => void;
+    onRemove?: () => void;
+    compact?: boolean;
+    placeholderOverride?: string;
+}
+declare function TokenSlotPill({ clause, isActive, invalid, invalidReason, onClick, onRemove, compact, placeholderOverride, }: TokenSlotPillProps): react.JSX.Element;
+
+/** Multi-select (toggle-in-place) clause types. `source` is independently
+ *  multi-select — applySourceFilter ORs the scope values. Typed tag keys and
+ *  `groupby` OR their values in the engine (value lists join with `|`). */
+declare const MULTI_VALUE_TYPES: Record<string, true>;
 
 interface CustomSlotEditorProps<TValue> {
     value: TValue | undefined;
@@ -515,47 +687,14 @@ declare class ComposerRegistry {
     private cachedList;
     registerSlot<TValue>(def: CustomSlotDefinition<TValue>): () => void;
     unregisterSlot(type: string): void;
-    getSlot(type: string): CustomSlotDefinition<any> | undefined;
-    listSlots(): CustomSlotDefinition<any>[];
-    getAllSlots(): CustomSlotDefinition<any>[];
+    getSlot(type: string): CustomSlotDefinition | undefined;
+    listSlots(): CustomSlotDefinition[];
+    getAllSlots(): CustomSlotDefinition[];
     subscribe(listener: () => void): () => void;
     private notify;
 }
 declare const composerRegistry: ComposerRegistry;
-declare function useComposerSlots(registry?: ComposerRegistry): CustomSlotDefinition<any>[];
-
-interface TokenSlotPillProps {
-    clause: QueryClause;
-    isActive?: boolean;
-    invalid?: boolean;
-    invalidReason?: string;
-    onClick?: () => void;
-    onRemove?: () => void;
-    onChange?: (patch: Partial<QueryClause>) => void;
-    compact?: boolean;
-    placeholderOverride?: string;
-}
-declare function TokenSlotPill({ clause, isActive, invalid, invalidReason, onClick, onRemove, onChange, compact, placeholderOverride, }: TokenSlotPillProps): react.JSX.Element;
-declare const MULTI_VALUE_TYPES: Record<string, true>;
-declare function ClausePopover({ clause, onClose, onChange, }: {
-    clause: QueryClause;
-    onClose: () => void;
-    onChange: (patch: Partial<QueryClause>) => void;
-}): react.JSX.Element;
-declare function CustomSlotPopover<TValue>({ clause, definition, onClose, onChange, }: {
-    clause: QueryClause;
-    definition: CustomSlotDefinition<TValue>;
-    onClose: () => void;
-    onChange: (value: TValue) => void;
-}): react.JSX.Element;
-declare function AddFilterDropdown({ clauses, onAdd, }: {
-    clauses: QueryClause[];
-    onAdd: (clause: QueryClause) => void;
-}): react.JSX.Element;
-declare function AddCalcDropdown({ clauses, onAdd, }: {
-    clauses: QueryClause[];
-    onAdd: (clause: QueryClause) => void;
-}): react.JSX.Element | null;
+declare function useComposerSlots(registry?: ComposerRegistry): CustomSlotDefinition[];
 
 interface DateRange {
     start: string;
@@ -581,7 +720,17 @@ interface SuggestionBinding {
 declare function tagsFromStaticBlocks(blocks: BlockIndexRow[]): string[];
 declare function catalogIdsFromBlocks(blocks: BlockIndexRow[]): string[];
 declare function blockTypesFromBlocks(blocks: BlockIndexRow[]): string[];
+/** Tags: user labels rank first with their spelling, corpus fills the rest —
+ *  one case-insensitive dedup path, insertion order kept (no global sort). */
 declare function mergeTagSuggestions(userLabels: string[], corpusLabels: string[]): string[];
+/** Canonical static block types — actual indexed corpus types rank ahead at runtime. */
+declare const CANONICAL_BLOCK_TYPES: readonly ["wod", "movement", "workout"];
+/** Suggestion items for a canonical readonly vocabulary; labels are display-only. */
+declare function canonicalSuggestionItems(values: readonly string[]): SuggestionItem[];
+/** Case-insensitive dedup by value key: vault entries keep their position,
+ *  enum keys take the canonical spelling, then remaining canonical values
+ *  append. First label wins — it is display-only. */
+declare function mergeSuggestionItems(vault: SuggestionItem[], canonical: SuggestionItem[]): SuggestionItem[];
 declare const SUGGESTION_BINDINGS: Record<string, SuggestionBinding>;
 declare function setSuggestionBinding(type: string, binding: SuggestionBinding | undefined): void;
 declare function getSuggestionBinding(type: string): SuggestionBinding | undefined;
@@ -599,7 +748,7 @@ declare function useSuggestions(type: string): ClauseSuggestions;
 
 interface WqlDiagnostics {
     valid: boolean;
-    /** The composed WQL string for the current clause set. */
+    /** Exact resolved draft text, including invalid input. */
     wql: string;
     ast: AnyParsedQuery;
     error?: string;
@@ -609,6 +758,7 @@ interface WqlFindSummary {
     target: string;
     scope: string;
     timeWindow?: string;
+    groupBy?: string;
     hasJoin: boolean;
     filterCount: number;
 }
@@ -624,16 +774,102 @@ interface WqlAggregateSummary {
     filterCount: number;
 }
 declare function summarizeAggregate(ast: ParsedAggregateQuery): WqlAggregateSummary;
-declare function diagnoseClauses(clauses: QueryClause[]): WqlDiagnostics;
+interface WqlPipelineSummary {
+    source: string;
+    /** One entry per transform stage, in order — `sum:tis`, `avg:load`, … */
+    functions: string[];
+    sink?: string;
+    timeWindow?: string;
+    filterCount: number;
+}
+declare function summarizePipeline(ast: ParsedPipelineQuery): WqlPipelineSummary;
 
 interface WqlDiagnosticsStripProps {
     diagnostics: WqlDiagnostics;
     offendingLabel?: string;
     stages?: WqlStageCounts;
+    /** Hide the AST summary chips (target/scope/time or agg/metric/by…) —
+     *  header contexts where the pills right below already show that state. */
+    hideSummary?: boolean;
+    /** 'card' (default) renders the rounded, bordered bubble. 'header' renders
+     *  a flat header section separated from the composer by an accent line. */
+    variant?: 'card' | 'header';
     actions?: ReactNode;
     className?: string;
 }
-declare function WqlDiagnosticsStrip({ diagnostics, offendingLabel, stages, actions, className, }: WqlDiagnosticsStripProps): react.JSX.Element;
+declare function WqlDiagnosticsStrip({ diagnostics, offendingLabel, stages, hideSummary, variant, actions, className, }: WqlDiagnosticsStripProps): react.JSX.Element;
+
+interface QueryDraft {
+    wql: string;
+    ast: AnyParsedQuery;
+    valid: boolean;
+    error?: string;
+}
+declare function wqlToPills(wql: string): QueryClause[] | null;
+declare function editQueryClause(query: string, edited: QueryClause, value: string | null): QueryDraft;
+declare function resolveQueryDraft(query: string, pendingText?: string): QueryDraft;
+
+interface EditorDialogProps {
+    /** Controls visibility; the dialog unmounts its portal when closed. */
+    open: boolean;
+    onClose: () => void;
+    /** Dialog heading (aria-labelledby target). */
+    title: string;
+    /** Optional secondary line under the title (aria-describedby target). */
+    description?: string;
+    /** Body content — scrolls independently of the header/footer. */
+    children: ReactNode;
+    /** Sticky footer (e.g. Cancel/Save) — pinned above the keyboard on mobile. */
+    footer?: ReactNode;
+    /** 'default' (centered/full-screen, unchanged) or 'sheet' (mobile bottom
+     *  sheet over the lower visible viewport, non-input initial focus,
+     *  safe-area footer; desktop keeps the centered panel). */
+    presentation?: 'default' | 'sheet';
+}
+/**
+ * EditorDialog — accessible editor surface shared by dashboard/effort/note
+ * editing flows.
+ *
+ * Deliberately NOT a native `<dialog>`: the top layer would obscure any
+ * body-portaled surfaces a host renders above it (the WQL composer's
+ * hover/touch affordances, palette results). This renders a plain fixed
+ * overlay via portal, so portaled content keeps painting and receiving
+ * clicks/focus above it.
+ *
+ * Focus containment is lenient by the same constraint: Tab cycles within the
+ * dialog only while focus is inside it — focus that moves into a body-portaled
+ * popover is never yanked back, and the popover keeps its own keyboard
+ * handling. Escape is handled at the dialog container, so Escape consumed by
+ * a popover (e.g. to dismiss it) does not also close the dialog.
+ *
+ * Mobile (< sm): full visual-viewport screen driven by `window.visualViewport`
+ * (falls back to `100dvh`) — the keyboard shrinking the viewport lifts the
+ * footer, never the focused field. Desktop (sm+): contained centered panel.
+ */
+declare function EditorDialog({ open, onClose, title, description, children, footer, presentation, }: EditorDialogProps): react.ReactPortal | null;
+
+interface VisualViewportRect {
+    /**
+     * Visible viewport height in px, or null when the VisualViewport API is
+     * unavailable (SSR, older engines). Consumers should fall back to a
+     * dynamic-viewport unit (e.g. `100dvh`) in that case.
+     */
+    height: number | null;
+    /** Distance from the layout viewport top to the visual viewport top (pinch-zoom). */
+    offsetTop: number;
+    /**
+     * Distance the visual viewport's bottom edge sits above the layout
+     * viewport's bottom edge — i.e. the on-screen keyboard's height (0 when
+     * the keyboard is closed).
+     */
+    offsetBottom: number;
+}
+/**
+ * Tracks `window.visualViewport` (resize + scroll). Drives keyboard-aware
+ * bottom-anchored UI (dialogs, thumb docks) without keyboard-size guessing
+ * or browser sniffing: the platform reports the visible rectangle.
+ */
+declare function useVisualViewportRect(): VisualViewportRect;
 
 declare function cn(...inputs: ClassValue[]): string;
 declare function hashCode(str: string): number;
@@ -658,13 +894,13 @@ declare function patchBlockQuery(blockContent: string, newQuery: string, queryIn
  * Auto-generated build version metadata.
  * Do not edit directly; updated by scripts/stamp-version.ts
  */
-declare const VERSION = "0.10.42";
-declare const GIT_SHA = "79c6d18";
-declare const BUILD_TIME = "2026-08-26T04:44:54.356Z";
+declare const VERSION = "0.35.2115";
+declare const GIT_SHA = "37944a8";
+declare const BUILD_TIME = "2026-10-11T23:54:36.367Z";
 declare const SEMVER: {
-    readonly version: "0.10.42";
-    readonly gitSha: "79c6d18";
-    readonly buildTime: "2026-08-26T04:44:54.356Z";
+    readonly version: "0.35.2115";
+    readonly gitSha: "37944a8";
+    readonly buildTime: "2026-10-11T23:54:36.367Z";
 };
 
-export { AGG_OPTIONS, ANALYTICS_UNIT_STORAGE_KEY, AddCalcDropdown, AddFilterDropdown, type AnalyticsQueriesState, type AnalyticsQueryDef, type AnalyticsRangeWeeks, type AnalyticsUnit, AnalyticsUnitPreference, type AnalyticsUnitPreferenceProps, BUILD_TIME, CLAUSE_META, CODEMIRROR_SINGLETON_DEPS, CONTENT_SOURCES, type ChartShape, type ClauseMeta, ClausePopover, type ClauseSuggestions, type ClauseType, ComposerRegistry, type CustomSlotDefinition, type CustomSlotEditorProps, CustomSlotPopover, DEFAULT_ANALYTICS_UNIT, DEFAULT_DIAGNOSTICS_DEBOUNCE_MS, DashboardTokenControls, type DashboardTokenControlsProps, DashboardView, type DashboardViewProps, type DateRange, type ExtractedQuery, GIT_SHA, GROUPBY_OPTIONS, GoalRings, type GoalRingsProps, METRIC_OPTIONS, MULTI_VALUE_TYPES, type MergedPoint, ProposedMetricBadge, QueryBlockView, type QueryBlockViewProps, type QueryClause, QueryExecutor, QueryValue, type QueryValueProps, ROLLUP_OPTIONS, RangeSelector, type RangeSelectorProps, RowsResultsChrome, type RowsResultsChromeProps, RowsTable, type RowsTableProps, SEMVER, SERIES_COLORS, SOURCE_OPTIONS, SUGGESTION_BINDINGS, StackedBar, type StackedBarProps, type StorageLike, type SuggestionBinding, type SuggestionCachePolicy, type SuggestionItem, TIME_OPTIONS, TokenSlotPill, type TokenSlotPillProps, TopList, type TopListProps, UNIT_OPTIONS, VERSION, WHERE_AGGREGATORS, WHERE_METRICS, WHERE_OPERATORS, WidgetChart, type WidgetChartProps, WidgetFrame, type WidgetFrameProps, WidgetProblemBadge, type WqlAggregateSummary, WqlBars, type WqlBarsProps, WqlComposer, type WqlComposerProps, type WqlDiagnostics, WqlDiagnosticsStrip, type WqlDiagnosticsStripProps, WqlEmptyState, type WqlEmptyStateProps, type WqlExecutor, type WqlFindSummary, WqlQueryInspectorModal, type WqlQueryInspectorModalProps, type WqlStageCounts, WqlTable, type WqlTableProps, WqlTimeseries, type WqlTimeseriesProps, type WqlValidationState, ZoneDistribution, type ZoneDistributionProps, blockTypesFromBlocks, catalogIdsFromBlocks, clauseToWql, clauseValue, clausesToWql, cn, compactNumber, composerRegistry, dateRangeSlot, defaultClauses, defaultMetricsClauses, diagnoseClauses, extractBlockQueries, formatTimestamp, getClauseMeta, getDashboardEffectiveUnit, getEffectiveAnalyticsUnit, getSuggestionBinding, hashCode, invalidateSuggestions, loadSuggestions, mergeSeries, mergeTagSuggestions, patchBlockQuery, pivotClauses, readSessionRpe, readStoredUnit, setMetricClause, setSuggestionBinding, sourcePlane, summarizeAggregate, summarizeFind, tagsFromStaticBlocks, tooltipTimestamp, useAnalyticsQueries, useAnalyticsUnitPreference, useChartShape, useComposerSlots, useSuggestions, useWqlStageCounts, wqlToClauses };
+export { AGG_OPTIONS, ANALYTICS_UNIT_STORAGE_KEY, type AnalyticsQueriesState, type AnalyticsQueryDef, type AnalyticsRangeWeeks, type AnalyticsUnit, AnalyticsUnitPreference, type AnalyticsUnitPreferenceProps, BUILD_TIME, CANONICAL_BLOCK_TYPES, CLAUSE_META, CODEMIRROR_SINGLETON_DEPS, type CategorizedMetrics, type ChartShape, type ClauseMeta, type ClauseSuggestions, type ClauseType, ComposerRegistry, type CustomSlotDefinition, type CustomSlotEditorProps, DEFAULT_ANALYTICS_UNIT, DEFAULT_DIAGNOSTICS_DEBOUNCE_MS, DEFAULT_OUTPUT_FILTERS, DEFAULT_PRIMARY_FILTER, type DashboardHeadingAnchor, DashboardTokenControls, type DashboardTokenControlsProps, DashboardView, type DashboardViewProps, type DateRange, EditorDialog, type EditorDialogProps, type ExtractedQuery, type FilterTypeaheadCandidate, type FilterTypeaheadMatch, GIT_SHA, GROUPBY_OPTIONS, GoalRings, type GoalRingsProps, KIND_OPTIONS, METRIC_OPTIONS, MULTI_VALUE_TYPES, type MergedPoint, MetricBadge, OUTPUT_TYPE_CLASS, OUTPUT_TYPE_DOT, type OutputFilterInput, OutputFilterPills, type OutputFilterPreset, type OutputStatementRow, OutputStatementsTable, type OutputStatementsTableProps, PLANE_OPTIONS, ProposedMetricBadge, QueryBlockView, type QueryBlockViewProps, type QueryClause, type QueryDraft, QueryExecutor, QueryValue, type QueryValueProps, ROLLUP_OPTIONS, RangeSelector, type RangeSelectorProps, RowsResultsChrome, type RowsResultsChromeProps, RowsTable, type RowsTableProps, SEMVER, SERIES_COLORS, SOURCE_OPTIONS, SUGGESTION_BINDINGS, StackedBar, type StackedBarProps, type StorageLike, type SuggestionBinding, type SuggestionCachePolicy, type SuggestionItem, TARGET_OPTIONS, TIME_OPTIONS, TONE_CLASS, TokenSlotPill, type TokenSlotPillProps, TopList, type TopListProps, UNIT_OPTIONS, VERSION, type VisualViewportRect, WHERE_AGGREGATORS, WHERE_METRICS, WidgetChart, type WidgetChartProps, WidgetEditButton, WidgetFrame, type WidgetFrameProps, WidgetProblemBadge, type WidgetSpanOption, WidgetToolButton, type WqlAggregateSummary, WqlBars, type WqlBarsProps, WqlComposer, type WqlComposerProps, type WqlDiagnostics, WqlDiagnosticsStrip, type WqlDiagnosticsStripProps, WqlEmptyState, type WqlEmptyStateProps, type WqlExecutor, type WqlFindSummary, type WqlPipelineSummary, WqlQueryInspectorModal, type WqlQueryInspectorModalProps, type WqlStageCounts, WqlTable, type WqlTableProps, WqlTimeseries, type WqlTimeseriesProps, type WqlValidationState, ZoneDistribution, type ZoneDistributionProps, blockTypesFromBlocks, canonicalSuggestionItems, catalogIdsFromBlocks, cn, compactNumber, composerRegistry, dateRangeSlot, editQueryClause, extractBlockQueries, extractMetricsByCategory, formatClockTime, formatMMSS, formatTimestamp, getClauseMeta, getDashboardEffectiveUnit, getEffectiveAnalyticsUnit, getSuggestionBinding, hashCode, invalidateSuggestions, loadSuggestions, matchFilterTypeahead, mergeSeries, mergeSuggestionItems, mergeTagSuggestions, normalizeOutputFilter, patchBlockQuery, presentBadges, readSessionRpe, readStoredUnit, resolveQueryDraft, setSuggestionBinding, summarizeAggregate, summarizeFind, summarizePipeline, tagsFromStaticBlocks, tooltipTimestamp, useAnalyticsQueries, useAnalyticsUnitPreference, useChartShape, useComposerSlots, useSuggestions, useVisualViewportRect, useWqlStageCounts, wqlToPills };