@elaraai/east-ui 1.0.39 → 1.0.41

package/dist/src/component.d.ts

@@ -2,7 +2,7 @@
  * Copyright (c) 2025 Elara AI Pty Ltd
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
-import { RecursiveType, VariantType, ArrayType, OptionType, StructType, StringType, IntegerType, FloatType, BooleanType, NullType, DateTimeType, BlobType, DictType, FunctionType } from "@elaraai/east";
+import { RecursiveType, VariantType, ArrayType, OptionType, StructType, StringType, IntegerType, FloatType, BooleanType, NullType, DateTimeType, BlobType, DictType, FunctionType, AsyncFunctionType } from "@elaraai/east";
 /**
  * Recursive type representing any UI component in East UI.
  *
@@ -2193,6 +2193,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly onResizeEnd: OptionType<FunctionType<[StructType<{
                 readonly size: ArrayType<FloatType>;
             }>], NullType>>;
+            readonly collapseBelow: OptionType<FloatType>;
         }>>;
     }>;
     /**
@@ -3877,6 +3878,62 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
         readonly render: FunctionType<[], import("@elaraai/east").RecursiveTypeMarker>;
         readonly navKey: StringType;
     }>;
+    /**
+     * App — the application shell (#367). Composes the navigation primitives
+     * into one surface: a collapsible nav rail, a breadcrumb app bar, an
+     * optional brand logo, app-bar slots, and the routed page body. The
+     * `App.Root` factory pre-builds `rail` / `breadcrumb` as `Reactive`
+     * NavList / Breadcrumb nodes (reading the shared `nav` handle) and `body`
+     * as a `Pages` node; the renderer is dumb layout + chrome (collapse state,
+     * `AppProvider` host-slot injection). `navKey` is the nav path's State key
+     * (collapse persistence + hotkey scope).
+     */
+    readonly App: StructType<{
+        readonly title: OptionType<StringType>;
+        readonly logo: OptionType<VariantType<{
+            readonly url: StringType;
+            readonly dataUri: StringType;
+            readonly blob: StructType<{
+                readonly bytes: BlobType;
+                readonly format: VariantType<{
+                    readonly png: NullType;
+                    readonly svg: NullType;
+                    readonly jpeg: NullType;
+                    readonly webp: NullType;
+                    readonly gif: NullType;
+                }>;
+            }>;
+        }>>;
+        readonly logoCollapsed: OptionType<VariantType<{
+            readonly url: StringType;
+            readonly dataUri: StringType;
+            readonly blob: StructType<{
+                readonly bytes: BlobType;
+                readonly format: VariantType<{
+                    readonly png: NullType;
+                    readonly svg: NullType;
+                    readonly jpeg: NullType;
+                    readonly webp: NullType;
+                    readonly gif: NullType;
+                }>;
+            }>;
+        }>>;
+        readonly rail: import("@elaraai/east").RecursiveTypeMarker;
+        readonly breadcrumb: import("@elaraai/east").RecursiveTypeMarker;
+        readonly body: import("@elaraai/east").RecursiveTypeMarker;
+        readonly barStart: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+        readonly barEnd: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+        readonly collapsible: BooleanType;
+        readonly themeToggle: BooleanType;
+        /** App-bar density — comfortable (2 rows) / compact (tighter 2 rows) /
+         *  condensed (breadcrumb + title on ONE row). Rail + body stay constant. */
+        readonly density: OptionType<VariantType<{
+            readonly comfortable: NullType;
+            readonly compact: NullType;
+            readonly condensed: NullType;
+        }>>;
+        readonly navKey: StringType;
+    }>;
     readonly Badge: StructType<{
         readonly value: StringType;
         readonly density: OptionType<VariantType<{
@@ -5055,86 +5112,819 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly md: NullType;
                 readonly lg: NullType;
             }>>;
-            readonly borderColor: OptionType<StringType>;
-        }>>;
-    }>;
-    readonly Trace: StructType<{
-        readonly tracks: ArrayType<StructType<{
-            readonly name: StringType;
-            readonly values: ArrayType<FloatType>;
-        }>>;
-        readonly now: OptionType<IntegerType>;
-        readonly axis: OptionType<ArrayType<StringType>>;
-        readonly density: OptionType<VariantType<{
-            readonly comfortable: NullType;
-            readonly compact: NullType;
-            readonly condensed: NullType;
-        }>>;
-        readonly scale: OptionType<VariantType<{
-            readonly brand: NullType;
-            readonly diverge: NullType;
-            readonly categorical: NullType;
-        }>>;
-        readonly future: OptionType<VariantType<{
-            readonly ghost: NullType;
-            readonly hatch: NullType;
-            readonly fade: NullType;
+            readonly borderColor: OptionType<StringType>;
+        }>>;
+    }>;
+    readonly Trace: StructType<{
+        readonly tracks: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly values: ArrayType<FloatType>;
+        }>>;
+        readonly now: OptionType<IntegerType>;
+        readonly axis: OptionType<ArrayType<StringType>>;
+        readonly density: OptionType<VariantType<{
+            readonly comfortable: NullType;
+            readonly compact: NullType;
+            readonly condensed: NullType;
+        }>>;
+        readonly scale: OptionType<VariantType<{
+            readonly brand: NullType;
+            readonly diverge: NullType;
+            readonly categorical: NullType;
+        }>>;
+        readonly future: OptionType<VariantType<{
+            readonly ghost: NullType;
+            readonly hatch: NullType;
+            readonly fade: NullType;
+        }>>;
+        readonly style: OptionType<StructType<{
+            readonly brandColor: OptionType<StringType>;
+            readonly nowLineColor: OptionType<StringType>;
+            readonly labelWidth: OptionType<StringType>;
+            readonly plotGutter: OptionType<StructType<{
+                readonly left: OptionType<StringType>;
+                readonly right: OptionType<StringType>;
+            }>>;
+        }>>;
+    }>;
+    readonly Library: StructType<{
+        readonly id: StringType;
+        readonly hint: OptionType<StringType>;
+        readonly items: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly sublabel: OptionType<StringType>;
+            readonly icon: OptionType<StringType>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+            }>>;
+            readonly draggable: BooleanType;
+            readonly filtered: BooleanType;
+            readonly search: OptionType<StringType>;
+            readonly groups: DictType<StringType, StringType>;
+            readonly dims: DictType<StringType, VariantType<{
+                readonly meter: StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                    readonly text: OptionType<StringType>;
+                }>;
+                readonly chips: ArrayType<StringType>;
+                readonly text: StringType;
+            }>>;
+        }>>;
+        readonly groupOptions: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+        }>>;
+        readonly groupSummaries: DictType<StringType, DictType<StringType, StringType>>;
+        readonly dimOptions: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+        }>>;
+        readonly defaultDimensions: ArrayType<StringType>;
+        readonly searchable: BooleanType;
+        readonly addLabel: OptionType<StringType>;
+        readonly onAdd: OptionType<FunctionType<[], NullType>>;
+        readonly slice: OptionType<StructType<{
+            readonly slice: StructType<{
+                readonly key: StringType;
+                readonly read: FunctionType<[], StructType<{
+                    readonly range: OptionType<VariantType<{
+                        readonly datetime: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                        readonly datetimePreset: VariantType<{
+                            readonly today: NullType;
+                            readonly last7d: NullType;
+                            readonly last30d: NullType;
+                            readonly last90d: NullType;
+                            readonly ytd: NullType;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly from: IntegerType;
+                            readonly to: IntegerType;
+                        }>;
+                        readonly float: StructType<{
+                            readonly from: FloatType;
+                            readonly to: FloatType;
+                        }>;
+                    }>>;
+                    readonly compare: OptionType<VariantType<{
+                        readonly previousPeriod: NullType;
+                        readonly previousYear: NullType;
+                    }>>;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly cohorts: ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly name: StringType;
+                        readonly filters: ArrayType<VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                    readonly startsWith: StringType;
+                                    readonly endsWith: StringType;
+                                    readonly isEmpty: NullType;
+                                    readonly isNotEmpty: NullType;
+                                }>;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: IntegerType;
+                                    readonly neq: IntegerType;
+                                    readonly lt: IntegerType;
+                                    readonly lte: IntegerType;
+                                    readonly gt: IntegerType;
+                                    readonly gte: IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                }>;
+                            }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly before: DateTimeType;
+                                    readonly after: DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: DateTimeType;
+                                        readonly to: DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>>;
+                    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                    readonly breakdown: OptionType<StructType<{
+                        readonly fieldId: StringType;
+                        readonly limit: OptionType<IntegerType>;
+                    }>>;
+                    readonly search: OptionType<StringType>;
+                    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                    readonly selectedIndex: OptionType<IntegerType>;
+                }>>;
+                readonly write: FunctionType<[StructType<{
+                    readonly range: OptionType<VariantType<{
+                        readonly datetime: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                        readonly datetimePreset: VariantType<{
+                            readonly today: NullType;
+                            readonly last7d: NullType;
+                            readonly last30d: NullType;
+                            readonly last90d: NullType;
+                            readonly ytd: NullType;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly from: IntegerType;
+                            readonly to: IntegerType;
+                        }>;
+                        readonly float: StructType<{
+                            readonly from: FloatType;
+                            readonly to: FloatType;
+                        }>;
+                    }>>;
+                    readonly compare: OptionType<VariantType<{
+                        readonly previousPeriod: NullType;
+                        readonly previousYear: NullType;
+                    }>>;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly cohorts: ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly name: StringType;
+                        readonly filters: ArrayType<VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                    readonly startsWith: StringType;
+                                    readonly endsWith: StringType;
+                                    readonly isEmpty: NullType;
+                                    readonly isNotEmpty: NullType;
+                                }>;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: IntegerType;
+                                    readonly neq: IntegerType;
+                                    readonly lt: IntegerType;
+                                    readonly lte: IntegerType;
+                                    readonly gt: IntegerType;
+                                    readonly gte: IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                }>;
+                            }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly before: DateTimeType;
+                                    readonly after: DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: DateTimeType;
+                                        readonly to: DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>>;
+                    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                    readonly breakdown: OptionType<StructType<{
+                        readonly fieldId: StringType;
+                        readonly limit: OptionType<IntegerType>;
+                    }>>;
+                    readonly search: OptionType<StringType>;
+                    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                    readonly selectedIndex: OptionType<IntegerType>;
+                }>], NullType>;
+                readonly setRange: FunctionType<[OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: IntegerType;
+                        readonly to: IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: FloatType;
+                    }>;
+                }>>], NullType>;
+                readonly setCompare: FunctionType<[OptionType<VariantType<{
+                    readonly previousPeriod: NullType;
+                    readonly previousYear: NullType;
+                }>>], NullType>;
+                readonly addFilter: FunctionType<[VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>], NullType>;
+                readonly removeFilter: FunctionType<[IntegerType], NullType>;
+                readonly clearFilters: FunctionType<[], NullType>;
+                readonly defineCohort: FunctionType<[StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                }>], NullType>;
+                readonly updateCohort: FunctionType<[StringType, StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                }>], NullType>;
+                readonly removeCohort: FunctionType<[StringType], NullType>;
+                readonly toggleCohort: FunctionType<[StringType], NullType>;
+                readonly setBreakdown: FunctionType<[OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<IntegerType>;
+                }>>], NullType>;
+                readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+                readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
+                readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
+                readonly isActive: FunctionType<[], BooleanType>;
+                readonly activeCount: FunctionType<[], IntegerType>;
+                readonly dimensions: FunctionType<[], ArrayType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly label: StringType;
+                }>>>;
+                readonly fields: FunctionType<[], ArrayType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly label: StringType;
+                    readonly kind: StringType;
+                    readonly hints: ArrayType<StringType>;
+                    readonly format: OptionType<VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: StringType;
+                            readonly compact: BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                }>>>;
+                readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+                readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+                readonly totalCount: FunctionType<[], IntegerType>;
+                readonly resultCount: FunctionType<[], IntegerType>;
+                readonly groups: FunctionType<[], ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly count: IntegerType;
+                    readonly color: StringType;
+                }>>>;
+                readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly color: StringType;
+                    readonly points: ArrayType<StructType<{
+                        readonly x: VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: DateTimeType;
+                        }>;
+                        readonly value: FloatType;
+                        readonly size: OptionType<FloatType>;
+                        readonly color: OptionType<StringType>;
+                    }>>;
+                }>>>;
+                readonly matches: FunctionType<[], ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly label: StringType;
+                    readonly meta: OptionType<StringType>;
+                }>>>;
+                readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
+                readonly toggleFilter: FunctionType<[VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>], NullType>;
+                readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly count: IntegerType;
+                    readonly color: StringType;
+                }>>>;
+            }>;
+            readonly affordances: ArrayType<VariantType<{
+                readonly filter: NullType;
+                readonly search: NullType;
+                readonly breakdown: NullType;
+                readonly range: NullType;
+                readonly cohort: NullType;
+                readonly brush: NullType;
+                readonly presets: NullType;
+                readonly legend: NullType;
+            }>>;
         }>>;
         readonly style: OptionType<StructType<{
-            readonly brandColor: OptionType<StringType>;
-            readonly nowLineColor: OptionType<StringType>;
-            readonly labelWidth: OptionType<StringType>;
-            readonly plotGutter: OptionType<StructType<{
-                readonly left: OptionType<StringType>;
-                readonly right: OptionType<StringType>;
-            }>>;
+            readonly height: OptionType<StringType>;
+            readonly maxHeight: OptionType<StringType>;
+            readonly virtualization: OptionType<BooleanType>;
         }>>;
     }>;
-    readonly Library: StructType<{
-        readonly id: StringType;
-        readonly hint: OptionType<StringType>;
+    readonly Deck: StructType<{
         readonly items: ArrayType<StructType<{
             readonly key: StringType;
-            readonly label: StringType;
+            readonly title: StringType;
             readonly sublabel: OptionType<StringType>;
             readonly icon: OptionType<StringType>;
-            readonly status: OptionType<StructType<{
+            readonly status: OptionType<StringType>;
+            readonly metrics: ArrayType<StructType<{
                 readonly label: StringType;
-                readonly tone: VariantType<{
+                readonly value: OptionType<FloatType>;
+                readonly format: OptionType<VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+                readonly text: OptionType<StringType>;
+                readonly warn: BooleanType;
+            }>>;
+            readonly fill: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+                readonly format: OptionType<VariantType<{
+                    readonly number: NullType;
+                    readonly currency: StructType<{
+                        readonly code: StringType;
+                        readonly compact: BooleanType;
+                    }>;
+                    readonly percent: NullType;
+                    readonly compact: NullType;
+                    readonly date: StringType;
+                    readonly time: StringType;
+                    readonly datetime: StringType;
+                }>>;
+                readonly text: OptionType<StringType>;
+            }>>;
+            readonly facts: ArrayType<StructType<{
+                readonly label: StringType;
+                readonly value: VariantType<{
+                    readonly meter: StructType<{
+                        readonly value: FloatType;
+                        readonly max: FloatType;
+                        readonly text: OptionType<StringType>;
+                    }>;
+                    readonly chips: ArrayType<StringType>;
+                    readonly text: StringType;
+                }>;
+            }>>;
+            readonly filtered: BooleanType;
+            readonly groups: DictType<StringType, StringType>;
+            readonly face: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly detail: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly hover: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+        }>>;
+        readonly statuses: DictType<StringType, StructType<{
+            readonly label: StringType;
+            readonly color: VariantType<{
+                readonly token: VariantType<{
                     readonly success: NullType;
                     readonly warning: NullType;
                     readonly danger: NullType;
                     readonly info: NullType;
                     readonly neutral: NullType;
                 }>;
-            }>>;
-            readonly draggable: BooleanType;
-            readonly filtered: BooleanType;
-            readonly search: OptionType<StringType>;
-            readonly groups: DictType<StringType, StringType>;
-            readonly dims: DictType<StringType, VariantType<{
-                readonly meter: StructType<{
-                    readonly value: FloatType;
-                    readonly max: FloatType;
-                    readonly text: OptionType<StringType>;
-                }>;
-                readonly chips: ArrayType<StringType>;
-                readonly text: StringType;
-            }>>;
+                readonly custom: StringType;
+            }>;
+            readonly pulse: BooleanType;
+            readonly hint: OptionType<StringType>;
         }>>;
         readonly groupOptions: ArrayType<StructType<{
             readonly key: StringType;
             readonly label: StringType;
         }>>;
         readonly groupSummaries: DictType<StringType, DictType<StringType, StringType>>;
-        readonly dimOptions: ArrayType<StructType<{
-            readonly key: StringType;
+        readonly footer: ArrayType<StructType<{
             readonly label: StringType;
+            readonly value: StringType;
         }>>;
-        readonly defaultDimensions: ArrayType<StringType>;
-        readonly searchable: BooleanType;
-        readonly addLabel: OptionType<StringType>;
-        readonly onAdd: OptionType<FunctionType<[], NullType>>;
+        readonly legend: BooleanType;
+        readonly layout: OptionType<VariantType<{
+            readonly grid: NullType;
+            readonly list: NullType;
+        }>>;
+        readonly onCardClick: OptionType<FunctionType<[StringType], NullType>>;
+        readonly onOpen: OptionType<AsyncFunctionType<[StringType], NullType>>;
+        readonly onClose: OptionType<AsyncFunctionType<[], NullType>>;
         readonly slice: OptionType<StructType<{
             readonly slice: StructType<{
                 readonly key: StringType;
@@ -5773,7 +6563,117 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
         readonly style: OptionType<StructType<{
             readonly height: OptionType<StringType>;
             readonly maxHeight: OptionType<StringType>;
-            readonly virtualization: OptionType<BooleanType>;
+            readonly minCardWidth: OptionType<StringType>;
+        }>>;
+    }>;
+    readonly DeckReadout: StructType<{
+        readonly cells: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly value: OptionType<FloatType>;
+            readonly format: OptionType<VariantType<{
+                readonly number: NullType;
+                readonly currency: StructType<{
+                    readonly code: StringType;
+                    readonly compact: BooleanType;
+                }>;
+                readonly percent: NullType;
+                readonly compact: NullType;
+                readonly date: StringType;
+                readonly time: StringType;
+                readonly datetime: StringType;
+            }>>;
+            readonly text: OptionType<StringType>;
+            readonly unit: OptionType<StringType>;
+            readonly warn: BooleanType;
+        }>>;
+    }>;
+    readonly DeckRows: StructType<{
+        readonly rows: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly value: StringType;
+        }>>;
+    }>;
+    readonly DeckNote: StructType<{
+        readonly text: StringType;
+    }>;
+    readonly ValueTree: StructType<{
+        readonly root: RecursiveType<VariantType<{
+            readonly struct: StructType<{
+                readonly fields: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly node: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+            }>;
+            readonly array: StructType<{
+                readonly items: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            }>;
+            readonly dict: StructType<{
+                readonly entries: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly node: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly editable: BooleanType;
+            }>;
+            readonly option: StructType<{
+                readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+            }>;
+            readonly variant: StructType<{
+                readonly tag: StringType;
+                readonly tags: ArrayType<StringType>;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly leaf: VariantType<{
+                readonly string: StringType;
+                readonly integer: IntegerType;
+                readonly float: FloatType;
+                readonly boolean: BooleanType;
+                readonly datetime: DateTimeType;
+                readonly null: NullType;
+            }>;
+            readonly opaque: StringType;
+        }>>;
+        readonly onEdit: OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+            readonly append: NullType;
+            readonly field: StringType;
+            readonly index: IntegerType;
+            readonly key: StringType;
+            readonly some: NullType;
+            readonly tag: NullType;
+        }>>, VariantType<{
+            readonly string: StringType;
+            readonly integer: IntegerType;
+            readonly float: FloatType;
+            readonly boolean: BooleanType;
+            readonly datetime: DateTimeType;
+            readonly null: NullType;
+        }>], NullType>>;
+        readonly onInsert: OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+            readonly append: NullType;
+            readonly field: StringType;
+            readonly index: IntegerType;
+            readonly key: StringType;
+            readonly some: NullType;
+            readonly tag: NullType;
+        }>>], NullType>>;
+        readonly onRemove: OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+            readonly append: NullType;
+            readonly field: StringType;
+            readonly index: IntegerType;
+            readonly key: StringType;
+            readonly some: NullType;
+            readonly tag: NullType;
+        }>>], NullType>>;
+        readonly onTag: OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+            readonly append: NullType;
+            readonly field: StringType;
+            readonly index: IntegerType;
+            readonly key: StringType;
+            readonly some: NullType;
+            readonly tag: NullType;
+        }>>, StringType], NullType>>;
+        readonly style: OptionType<StructType<{
+            readonly height: OptionType<StringType>;
+            readonly maxHeight: OptionType<StringType>;
         }>>;
     }>;
     readonly SliceSummary: StructType<{
@@ -15136,19 +16036,52 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
         }>>;
     }>;
     readonly Calendar: StructType<{
-        readonly legend: StringType;
         readonly cells: ArrayType<StructType<{
             readonly week: StringType;
             readonly day: StringType;
             readonly value: FloatType;
             readonly text: StringType;
+            readonly compare: OptionType<FloatType>;
             readonly summary: OptionType<StringType>;
-            readonly delta: OptionType<FloatType>;
+        }>>;
+        readonly values: BooleanType;
+        readonly scale: OptionType<StructType<{
+            readonly ramp: OptionType<ArrayType<StringType>>;
+            readonly steps: IntegerType;
         }>>;
         readonly domain: OptionType<StructType<{
             readonly min: FloatType;
             readonly max: FloatType;
         }>>;
+        readonly totals: OptionType<StructType<{
+            readonly aggregate: VariantType<{
+                readonly sum: NullType;
+                readonly mean: NullType;
+                readonly min: NullType;
+                readonly max: NullType;
+                readonly count: NullType;
+            }>;
+            readonly label: StringType;
+            readonly bar: BooleanType;
+        }>>;
+        readonly aggregateRow: OptionType<StructType<{
+            readonly aggregate: VariantType<{
+                readonly sum: NullType;
+                readonly mean: NullType;
+                readonly min: NullType;
+                readonly max: NullType;
+                readonly count: NullType;
+            }>;
+            readonly label: StringType;
+        }>>;
+        readonly footer: OptionType<StructType<{
+            readonly valueLabel: StringType;
+            readonly compareLabel: StringType;
+            readonly legend: OptionType<StructType<{
+                readonly low: StringType;
+                readonly high: StringType;
+            }>>;
+        }>>;
         readonly actionLabel: OptionType<StringType>;
         readonly onAction: OptionType<FunctionType<[StructType<{
             readonly week: StringType;
@@ -17225,6 +18158,59 @@ export declare const UIComponentType: RecursiveType<UIComponentNode>;
  * Type alias for UIComponentType.
  */
 export type UIComponentType = typeof UIComponentType;
+/**
+ * Standalone `StructType` mirroring the inline `App` variant payload (#367) — the
+ * renderer derives its decoded value type (`ValueTypeOf`) and memo comparator
+ * (`equalFor`) from this. Keep it in **lockstep** with the `App:` case in the
+ * variant above (the inline case uses `node` for recursion; this uses the
+ * resolved `UIComponentType`, which is structurally identical).
+ */
+export declare const AppValueType: StructType<{
+    readonly title: OptionType<StringType>;
+    readonly logo: OptionType<VariantType<{
+        readonly url: StringType;
+        readonly dataUri: StringType;
+        readonly blob: StructType<{
+            readonly bytes: BlobType;
+            readonly format: VariantType<{
+                readonly png: NullType;
+                readonly svg: NullType;
+                readonly jpeg: NullType;
+                readonly webp: NullType;
+                readonly gif: NullType;
+            }>;
+        }>;
+    }>>;
+    readonly logoCollapsed: OptionType<VariantType<{
+        readonly url: StringType;
+        readonly dataUri: StringType;
+        readonly blob: StructType<{
+            readonly bytes: BlobType;
+            readonly format: VariantType<{
+                readonly png: NullType;
+                readonly svg: NullType;
+                readonly jpeg: NullType;
+                readonly webp: NullType;
+                readonly gif: NullType;
+            }>;
+        }>;
+    }>>;
+    readonly rail: RecursiveType<UIComponentNode>;
+    readonly breadcrumb: RecursiveType<UIComponentNode>;
+    readonly body: RecursiveType<UIComponentNode>;
+    readonly barStart: ArrayType<RecursiveType<UIComponentNode>>;
+    readonly barEnd: ArrayType<RecursiveType<UIComponentNode>>;
+    readonly collapsible: BooleanType;
+    readonly themeToggle: BooleanType;
+    readonly density: OptionType<VariantType<{
+        readonly comfortable: NullType;
+        readonly compact: NullType;
+        readonly condensed: NullType;
+    }>>;
+    readonly navKey: StringType;
+}>;
+/** Type alias for {@link AppValueType}. */
+export type AppValueType = typeof AppValueType;
 /**
  * Shared overlay input — a UIComponent positioned inside a container
  * via the same axis-based `align` / `verticalAlign` pair used for