@elaraai/east-ui 1.0.4 → 1.0.6

package/dist/src/platform/slice/index.d.ts

@@ -144,6 +144,83 @@ export declare const SliceCompareType: VariantType<{
     readonly previousYear: NullType;
 }>;
 export type SliceCompareType = typeof SliceCompareType;
+/**
+ * Schema configuration for a slice. Declares every dimension on `T` that
+ * the user can filter, search, break by, or restrict via Range.
+ *
+ * The module-scope value uses the `"T"` placeholder for use inside the
+ * `slice_bind` generic-platform declaration. Consumer code never touches
+ * this — `Slice.config({...})` materialises a concrete instance per row
+ * type internally.
+ *
+ * @property fields            - Dict of declared dimensions keyed by `fieldId`
+ * @property rangeFieldId      - Optional id of the field `Slice.Range` narrows on.
+ *                                Must reference a datetime / integer / float field.
+ *                                Renderer dispatches the right control based on the
+ *                                field's type.
+ * @property searchFieldIds    - Fields the typeahead search applies to
+ * @property breakdownFieldIds - Fields available as breakdown dimensions
+ */
+/**
+ * Materialise the concrete `SliceConfig` East type for a row type — for
+ * payloads that carry a slice config across an encoding boundary (e.g. a
+ * `DecisionQueue`'s queue-owned slice). The module-scope `SliceConfigType`
+ * keeps the `"T"` placeholder for the `slice_bind` declaration.
+ */
+export declare function sliceConfigTypeFor<T extends EastType>(rowType: T): StructType<{
+    readonly fields: DictType<StringType, VariantType<{
+        readonly string: StructType<{
+            readonly label: StringType;
+            readonly accessor: FunctionType<[T], StringType>;
+        }>;
+        readonly integer: StructType<{
+            readonly label: StringType;
+            readonly accessor: FunctionType<[T], IntegerType>;
+        }>;
+        readonly float: StructType<{
+            readonly label: StringType;
+            readonly accessor: FunctionType<[T], FloatType>;
+        }>;
+        readonly datetime: StructType<{
+            readonly label: StringType;
+            readonly accessor: FunctionType<[T], DateTimeType>;
+        }>;
+        readonly boolean: StructType<{
+            readonly label: StringType;
+            readonly accessor: FunctionType<[T], BooleanType>;
+        }>;
+    }>>;
+    readonly rangeFieldId: OptionType<StringType>;
+    readonly searchFieldIds: ArrayType<StringType>;
+    readonly breakdownFieldIds: ArrayType<StringType>;
+}>;
+export declare const SliceConfigType: StructType<{
+    readonly fields: DictType<StringType, VariantType<{
+        readonly string: StructType<{
+            readonly label: StringType;
+            readonly accessor: FunctionType<["T"], StringType>;
+        }>;
+        readonly integer: StructType<{
+            readonly label: StringType;
+            readonly accessor: FunctionType<["T"], IntegerType>;
+        }>;
+        readonly float: StructType<{
+            readonly label: StringType;
+            readonly accessor: FunctionType<["T"], FloatType>;
+        }>;
+        readonly datetime: StructType<{
+            readonly label: StringType;
+            readonly accessor: FunctionType<["T"], DateTimeType>;
+        }>;
+        readonly boolean: StructType<{
+            readonly label: StringType;
+            readonly accessor: FunctionType<["T"], BooleanType>;
+        }>;
+    }>>;
+    readonly rangeFieldId: OptionType<StringType>;
+    readonly searchFieldIds: ArrayType<StringType>;
+    readonly breakdownFieldIds: ArrayType<StringType>;
+}>;
 /**
  * One field declaration in `Slice.config`. Only the label is required —
  * the accessor is auto-derived as `r => r[fieldId]` and the field's kind
@@ -854,14 +931,27 @@ export declare const SliceBreakdownGroupArrayType: ArrayType<StructType<{
 }>>;
 export type SliceBreakdownGroupArrayType = typeof SliceBreakdownGroupArrayType;
 /**
- * One point of a pivoted series — an x-axis position and its aggregated value.
+ * One point of a pivoted series — a typed x position and its aggregated value.
  *
- * @property x     - Stringified x-axis value (the point's position along the axis)
+ * @remarks
+ * The x coordinate is the chart's {@link ChartXType} (band category / linear
+ * number / time date), so the pivot feeds `Chart.Spec.series` directly and the
+ * renderer derives the scale from the coordinate.
+ *
+ * @property x     - The point's typed x coordinate
  * @property value - Aggregated (summed) numeric value at this `x`
+ * @property size  - Mirrors {@link ChartPointType} so the pivot feeds
+ *                   `Chart.Spec.series` directly; always `none` (slice series
+ *                   carry no per-point bubble magnitude)
  */
 export declare const SliceSeriesPointType: StructType<{
-    readonly x: StringType;
+    readonly x: VariantType<{
+        readonly category: StringType;
+        readonly number: FloatType;
+        readonly time: DateTimeType;
+    }>;
     readonly value: FloatType;
+    readonly size: OptionType<FloatType>;
 }>;
 export type SliceSeriesPointType = typeof SliceSeriesPointType;
 /**
@@ -878,8 +968,13 @@ export declare const SliceSeriesType: StructType<{
     readonly key: StringType;
     readonly color: StringType;
     readonly points: ArrayType<StructType<{
-        readonly x: StringType;
+        readonly x: VariantType<{
+            readonly category: StringType;
+            readonly number: FloatType;
+            readonly time: DateTimeType;
+        }>;
         readonly value: FloatType;
+        readonly size: OptionType<FloatType>;
     }>>;
 }>;
 export type SliceSeriesType = typeof SliceSeriesType;
@@ -888,16 +983,21 @@ export declare const SliceSeriesArrayType: ArrayType<StructType<{
     readonly key: StringType;
     readonly color: StringType;
     readonly points: ArrayType<StructType<{
-        readonly x: StringType;
+        readonly x: VariantType<{
+            readonly category: StringType;
+            readonly number: FloatType;
+            readonly time: DateTimeType;
+        }>;
         readonly value: FloatType;
+        readonly size: OptionType<FloatType>;
     }>>;
 }>>;
 export type SliceSeriesArrayType = typeof SliceSeriesArrayType;
 /**
  * Render density for a `Slice.*` affordance. `compact` = the one-row eyebrow
- * form used inside a `Slice.Frame`; `focused` = the standalone configuration
+ * form used inside a chrome rail; `focused` = the standalone configuration
  * surface. Components default to `focused` standalone and `compact` when the
- * surrounding `Slice.Frame` sets the density.
+ * surrounding rail sets the density.
  */
 export declare const SliceDensityType: VariantType<{
     readonly compact: NullType;
@@ -1433,11 +1533,11 @@ export declare const SliceBindType: StructType<{
         readonly label: StringType;
         readonly kind: StringType;
     }>>>;
-    /** Field ids the typeahead searches over — `Slice.Frame` shows Search when non-empty. */
+    /** Field ids the typeahead searches over — the chrome rail shows Search when non-empty. */
     readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
-    /** Field id `Slice.Range` narrows on — `Slice.Frame` shows Range when `some`. */
+    /** Field id `Slice.Range` narrows on — the chrome rail shows Range when `some`. */
     readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
-    /** Total bound rows, before any narrowing — used by the `Slice.Frame` footer ("N of M"). */
+    /** Total bound rows, before any narrowing — used by the chrome footer ("N of M"). */
     readonly totalCount: FunctionType<[], IntegerType>;
     /** Count of bound rows passing every active narrowing — used by Filter / Summary. */
     readonly resultCount: FunctionType<[], IntegerType>;
@@ -1459,8 +1559,13 @@ export declare const SliceBindType: StructType<{
         readonly key: StringType;
         readonly color: StringType;
         readonly points: ArrayType<StructType<{
-            readonly x: StringType;
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: DateTimeType;
+            }>;
             readonly value: FloatType;
+            readonly size: OptionType<FloatType>;
         }>>;
     }>>>;
     /** Typeahead suggestions for the current query (via the bind `toMatch`) → `[{ id, label, meta }]`. */
@@ -1474,102 +1579,1106 @@ export declare const SliceBindType: StructType<{
 }>;
 export type SliceBindType = typeof SliceBindType;
 /**
- * Slice platform — typed narrowing state for the `Slice.*` UI family.
- *
- * @example
- * ```ts
- * import { East, ArrayType, StringType, IntegerType, NullType, variant, some, none } from "@elaraai/east";
- * import { Reactive, Slice, Text, UIComponentType } from "@elaraai/east-ui";
- *
- * // 1. Declare the row type
- * const UserEventType = StructType({
- *     timestamp: DateTimeType,
- *     country:   StringType,
- *     sessions:  IntegerType,
- * });
- *
- * const view = East.function([], UIComponentType, (_$) => {
- *     return Reactive.Root(East.function([], UIComponentType, $ => {
- *         // 2. Bind with a config declaring available dimensions
- *         const slice = $.let(Slice.bind("view.events", East.value({
- *             fields: new Map([
- *                 ["timestamp", variant("datetime", { label: "Time",     accessor: East.function([UserEventType], DateTimeType, ($, r) => r.timestamp) })],
- *                 ["country",   variant("string",   { label: "Country",  accessor: East.function([UserEventType], StringType,   ($, r) => r.country)   })],
- *                 ["sessions",  variant("integer",  { label: "Sessions", accessor: East.function([UserEventType], IntegerType,  ($, r) => r.sessions)  })],
- *             ]),
- *             timeFieldId:       some("timestamp"),
- *             searchFieldIds:    ["country"],
- *             breakdownFieldIds: ["country"],
- *         })));
- *
- *         // 3. Add a TYPED filter — `integerGte` carries an IntegerType, not a parsed string
- *         $(slice.addFilter(East.value({
- *             fieldId: "sessions",
- *             op:      variant("integerGte", 10n),
- *         }, Slice.Types.Predicate)));
- *
- *         // 4. Apply: pure narrowing engine
- *         //    const filtered = $.let(Slice.apply.where(slice.read(), config, events));
- *
- *         const state = $.let(slice.read(), Slice.Types.State);
- *         return Text.Root(East.str`${state.filters.length()} active filters`);
- *     }));
- * });
- * ```
+ * The slice-chrome payload every slice-accepting component carries — the
+ * bound handle plus the affordances its rail mounts. Chrome only: the
+ * component's data is always fed explicitly (`Slice.rows([RowType], slice)`).
  */
-export declare const Slice: {
-    /**
-     * Bind a slice to a named key. Returns a closure struct UI components
-     * plug into and downstream consumers read.
-     *
-     * The third argument is the initial `SliceState` — built ergonomically
-     * with `Slice.state({...})` (omitted fields default to "no narrowing
-     * active"). First bind for a key seeds the store with it; subsequent
-     * binds return a fresh closure struct over the existing state and ignore
-     * the initial value. `read()` tracks the dependency so `Reactive.Root`
-     * re-renders on change.
-     *
-     * @example
-     * ```ts
-     * // Empty slice — all defaults
-     * const slice = $.let(Slice.bind([EventType], "view.events", cfg, Slice.state({})));
-     *
-     * // Seeded — a preset range and an active cohort on first bind
-     * const seeded = $.let(Slice.bind([EventType], "view.seeded", cfg, Slice.state({
-     *     range:         some(variant("datetimePreset", variant("last30d", null))),
-     *     cohorts:       [{ id: "power", name: "Power users", filters: [] }],
-     *     activeCohorts: new Set(["power"]),
-     * })));
-     * ```
-     */
-    readonly bind: import("@elaraai/east").GenericPlatformDefinition<readonly ["T"], readonly [StringType, StructType<{
-        readonly fields: DictType<StringType, VariantType<{
-            readonly string: StructType<{
-                readonly label: StringType;
-                readonly accessor: FunctionType<["T"], StringType>;
-            }>;
-            readonly integer: StructType<{
-                readonly label: StringType;
-                readonly accessor: FunctionType<["T"], IntegerType>;
-            }>;
-            readonly float: StructType<{
-                readonly label: StringType;
-                readonly accessor: FunctionType<["T"], FloatType>;
-            }>;
-            readonly datetime: StructType<{
-                readonly label: StringType;
-                readonly accessor: FunctionType<["T"], DateTimeType>;
-            }>;
-            readonly boolean: StructType<{
-                readonly label: StringType;
-                readonly accessor: FunctionType<["T"], BooleanType>;
-            }>;
-        }>>;
-        readonly rangeFieldId: OptionType<StringType>;
-        readonly searchFieldIds: ArrayType<StringType>;
-        readonly breakdownFieldIds: ArrayType<StringType>;
-    }>, StructType<{
-        readonly range: OptionType<VariantType<{
+export declare const SliceChromeType: StructType<{
+    readonly slice: StructType<{
+        /** The store key this slice is bound to — lets renderers self-subscribe. */
+        readonly key: StringType;
+        /** Read the entire slice state; tracked for reactive re-render. */
+        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: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                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: 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: SetType<StringType>;
+                            readonly notIn: SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                        }>;
+                    }>;
+                    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: 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: SetType<StringType>;
+            readonly breakdown: OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>;
+            readonly search: OptionType<StringType>;
+            readonly visible: OptionType<SetType<StringType>>;
+            readonly selectedIndex: OptionType<IntegerType>;
+        }>>;
+        /** Replace the entire slice state. Rare — prefer the structured mutators. */
+        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: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                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: 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: SetType<StringType>;
+                            readonly notIn: SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                        }>;
+                    }>;
+                    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: 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: SetType<StringType>;
+            readonly breakdown: OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>;
+            readonly search: OptionType<StringType>;
+            readonly visible: OptionType<SetType<StringType>>;
+            readonly selectedIndex: OptionType<IntegerType>;
+        }>], NullType>;
+        /** Set or clear the ranged narrowing. `none` clears; `some(range)` activates. */
+        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>;
+        /** Set or clear the comparison period. `none` clears. */
+        readonly setCompare: FunctionType<[OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>], NullType>;
+        /** Append a new filter clause to the AND chain. */
+        readonly addFilter: FunctionType<[VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            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: 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>;
+        /** Remove the filter at the given index. */
+        readonly removeFilter: FunctionType<[IntegerType], NullType>;
+        /** Clear every applied filter (and active cohorts). */
+        readonly clearFilters: FunctionType<[], NullType>;
+        /** Register a new cohort definition. Errors if id already exists. */
+        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: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                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: 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>;
+        /** Replace the cohort with the given id in place (keeps active state). */
+        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: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                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: 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>;
+        /** Drop a cohort from the registry (and from active cohorts). */
+        readonly removeCohort: FunctionType<[StringType], NullType>;
+        /** Flip whether the cohort with this id is being applied. */
+        readonly toggleCohort: FunctionType<[StringType], NullType>;
+        /** Set or clear the group-by dimension. `none` = no breakdown. */
+        readonly setBreakdown: FunctionType<[OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>], NullType>;
+        /** Set the typeahead query. `none` clears; `some("query")` activates it. */
+        readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+        /** Set the visible-series whitelist. `none` = all series visible. */
+        readonly setVisible: FunctionType<[OptionType<SetType<StringType>>], NullType>;
+        /** Set the master-detail selection index. `none` = no selection. */
+        readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
+        /** True when at least one narrowing is active. */
+        readonly isActive: FunctionType<[], BooleanType>;
+        /** Count of currently-applied narrowings — used by `Slice.Summary`. */
+        readonly activeCount: FunctionType<[], IntegerType>;
+        /** Selectable breakdown dimensions for this slice's config → `[{ fieldId, label }]`. */
+        readonly dimensions: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
+            readonly label: StringType;
+        }>>>;
+        /** Every filterable field → `[{ fieldId, label, kind }]`; feeds the predicate builder. */
+        readonly fields: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
+            readonly label: StringType;
+            readonly kind: StringType;
+        }>>>;
+        /** Field ids the typeahead searches over — the chrome rail shows Search when non-empty. */
+        readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+        /** Field id `Slice.Range` narrows on — the chrome rail shows Range when `some`. */
+        readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+        /** Total bound rows, before any narrowing — used by the chrome footer ("N of M"). */
+        readonly totalCount: FunctionType<[], IntegerType>;
+        /** Count of bound rows passing every active narrowing — used by Filter / Summary. */
+        readonly resultCount: FunctionType<[], IntegerType>;
+        /** Active-breakdown series over the bound rows → `[{ key, count }]` — Breakdown / Legend. */
+        readonly groups: FunctionType<[], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly count: IntegerType;
+            readonly color: StringType;
+        }>>>;
+        /**
+         * Pivot the narrowed rows into chart-ready multi-series long format:
+         * grouped by the active breakdown dimension (`key`) and the given x-axis
+         * field, summing the value field → `[{ key, x, value }]`. Feed a
+         * multi-series chart by filtering per (statically-known) series key.
+         * @param xFieldId     - field whose value positions each point on the x-axis
+         * @param valueFieldId - numeric field summed into each point's `value`
+         */
+        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>;
+            }>>;
+        }>>>;
+        /** Typeahead suggestions for the current query (via the bind `toMatch`) → `[{ id, label, meta }]`. */
+        readonly matches: FunctionType<[], ArrayType<StructType<{
+            readonly id: StringType;
+            readonly label: StringType;
+            readonly meta: OptionType<StringType>;
+        }>>>;
+        /** Size of each cohort over the bound rows, keyed by cohort id — Cohort chips. */
+        readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
+    }>;
+    readonly affordances: ArrayType<VariantType<{
+        readonly filter: NullType;
+        readonly search: NullType;
+        readonly breakdown: NullType;
+        readonly range: NullType;
+        readonly cohort: NullType;
+        readonly brush: NullType;
+    }>>;
+}>;
+/** Type alias for {@link SliceChromeType}. */
+export type SliceChromeType = typeof SliceChromeType;
+/**
+ * Slice platform — typed narrowing state for the `Slice.*` UI family.
+ *
+ * @example
+ * ```ts
+ * import { East, ArrayType, StringType, IntegerType, NullType, variant, some, none } from "@elaraai/east";
+ * import { Reactive, Slice, Text, UIComponentType } from "@elaraai/east-ui";
+ *
+ * // 1. Declare the row type
+ * const UserEventType = StructType({
+ *     timestamp: DateTimeType,
+ *     country:   StringType,
+ *     sessions:  IntegerType,
+ * });
+ *
+ * const view = East.function([], UIComponentType, (_$) => {
+ *     return Reactive.Root(East.function([], UIComponentType, $ => {
+ *         // 2. Bind with a config declaring available dimensions
+ *         const slice = $.let(Slice.bind("view.events", East.value({
+ *             fields: new Map([
+ *                 ["timestamp", variant("datetime", { label: "Time",     accessor: East.function([UserEventType], DateTimeType, ($, r) => r.timestamp) })],
+ *                 ["country",   variant("string",   { label: "Country",  accessor: East.function([UserEventType], StringType,   ($, r) => r.country)   })],
+ *                 ["sessions",  variant("integer",  { label: "Sessions", accessor: East.function([UserEventType], IntegerType,  ($, r) => r.sessions)  })],
+ *             ]),
+ *             timeFieldId:       some("timestamp"),
+ *             searchFieldIds:    ["country"],
+ *             breakdownFieldIds: ["country"],
+ *         })));
+ *
+ *         // 3. Add a TYPED filter — `integerGte` carries an IntegerType, not a parsed string
+ *         $(slice.addFilter(East.value({
+ *             fieldId: "sessions",
+ *             op:      variant("integerGte", 10n),
+ *         }, Slice.Types.Predicate)));
+ *
+ *         // 4. Apply: pure narrowing engine
+ *         //    const filtered = $.let(Slice.apply.where(slice.read(), config, events));
+ *
+ *         const state = $.let(slice.read(), Slice.Types.State);
+ *         return Text.Root(East.str`${state.filters.length()} active filters`);
+ *     }));
+ * });
+ * ```
+ */
+export declare const Slice: {
+    /**
+     * Bind a slice to a named key. Returns a closure struct UI components
+     * plug into and downstream consumers read.
+     *
+     * The third argument is the initial `SliceState` — built ergonomically
+     * with `Slice.state({...})` (omitted fields default to "no narrowing
+     * active"). First bind for a key seeds the store with it; subsequent
+     * binds return a fresh closure struct over the existing state and ignore
+     * the initial value. `read()` tracks the dependency so `Reactive.Root`
+     * re-renders on change.
+     *
+     * @example
+     * ```ts
+     * // Empty slice — all defaults
+     * const slice = $.let(Slice.bind([EventType], "view.events", cfg, Slice.state({})));
+     *
+     * // Seeded — a preset range and an active cohort on first bind
+     * const seeded = $.let(Slice.bind([EventType], "view.seeded", cfg, Slice.state({
+     *     range:         some(variant("datetimePreset", variant("last30d", null))),
+     *     cohorts:       [{ id: "power", name: "Power users", filters: [] }],
+     *     activeCohorts: new Set(["power"]),
+     * })));
+     * ```
+     */
+    readonly bind: import("@elaraai/east").GenericPlatformDefinition<readonly ["T"], readonly [StringType, StructType<{
+        readonly fields: DictType<StringType, VariantType<{
+            readonly string: StructType<{
+                readonly label: StringType;
+                readonly accessor: FunctionType<["T"], StringType>;
+            }>;
+            readonly integer: StructType<{
+                readonly label: StringType;
+                readonly accessor: FunctionType<["T"], IntegerType>;
+            }>;
+            readonly float: StructType<{
+                readonly label: StringType;
+                readonly accessor: FunctionType<["T"], FloatType>;
+            }>;
+            readonly datetime: StructType<{
+                readonly label: StringType;
+                readonly accessor: FunctionType<["T"], DateTimeType>;
+            }>;
+            readonly boolean: StructType<{
+                readonly label: StringType;
+                readonly accessor: FunctionType<["T"], BooleanType>;
+            }>;
+        }>>;
+        readonly rangeFieldId: OptionType<StringType>;
+        readonly searchFieldIds: ArrayType<StringType>;
+        readonly breakdownFieldIds: ArrayType<StringType>;
+    }>, 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: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            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: 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: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                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: 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: SetType<StringType>;
+        readonly breakdown: OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>;
+        readonly search: OptionType<StringType>;
+        readonly visible: OptionType<SetType<StringType>>;
+        readonly selectedIndex: OptionType<IntegerType>;
+    }>, ArrayType<"T">, OptionType<FunctionType<["T"], StructType<{
+        readonly id: StringType;
+        readonly label: StringType;
+        readonly meta: OptionType<StringType>;
+    }>>>], StructType<{
+        /** The store key this slice is bound to — lets renderers self-subscribe. */
+        readonly key: StringType;
+        /** Read the entire slice state; tracked for reactive re-render. */
+        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: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                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: 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: SetType<StringType>;
+                            readonly notIn: SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                        }>;
+                    }>;
+                    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: 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: SetType<StringType>;
+            readonly breakdown: OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>;
+            readonly search: OptionType<StringType>;
+            readonly visible: OptionType<SetType<StringType>>;
+            readonly selectedIndex: OptionType<IntegerType>;
+        }>>;
+        /** Replace the entire slice state. Rare — prefer the structured mutators. */
+        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: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                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: 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: SetType<StringType>;
+                            readonly notIn: SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                        }>;
+                    }>;
+                    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: 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: SetType<StringType>;
+            readonly breakdown: OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<IntegerType>;
+            }>>;
+            readonly search: OptionType<StringType>;
+            readonly visible: OptionType<SetType<StringType>>;
+            readonly selectedIndex: OptionType<IntegerType>;
+        }>], NullType>;
+        /** Set or clear the ranged narrowing. `none` clears; `some(range)` activates. */
+        readonly setRange: FunctionType<[OptionType<VariantType<{
             readonly datetime: StructType<{
                 readonly from: DateTimeType;
                 readonly to: DateTimeType;
@@ -1589,12 +2698,14 @@ export declare const Slice: {
                 readonly from: FloatType;
                 readonly to: FloatType;
             }>;
-        }>>;
-        readonly compare: OptionType<VariantType<{
+        }>>], NullType>;
+        /** Set or clear the comparison period. `none` clears. */
+        readonly setCompare: FunctionType<[OptionType<VariantType<{
             readonly previousPeriod: NullType;
             readonly previousYear: NullType;
-        }>>;
-        readonly filters: ArrayType<VariantType<{
+        }>>], NullType>;
+        /** Append a new filter clause to the AND chain. */
+        readonly addFilter: FunctionType<[VariantType<{
             readonly string: StructType<{
                 readonly fieldId: StringType;
                 readonly op: VariantType<{
@@ -1644,8 +2755,13 @@ export declare const Slice: {
                     readonly is: BooleanType;
                 }>;
             }>;
-        }>>;
-        readonly cohorts: ArrayType<StructType<{
+        }>], NullType>;
+        /** Remove the filter at the given index. */
+        readonly removeFilter: FunctionType<[IntegerType], NullType>;
+        /** Clear every applied filter (and active cohorts). */
+        readonly clearFilters: FunctionType<[], NullType>;
+        /** Register a new cohort definition. Errors if id already exists. */
+        readonly defineCohort: FunctionType<[StructType<{
             readonly id: StringType;
             readonly name: StringType;
             readonly filters: ArrayType<VariantType<{
@@ -1699,20 +2815,139 @@ export declare const Slice: {
                     }>;
                 }>;
             }>>;
-        }>>;
-        readonly activeCohorts: SetType<StringType>;
-        readonly breakdown: OptionType<StructType<{
+        }>], NullType>;
+        /** Replace the cohort with the given id in place (keeps active state). */
+        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: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                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: 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>;
+        /** Drop a cohort from the registry (and from active cohorts). */
+        readonly removeCohort: FunctionType<[StringType], NullType>;
+        /** Flip whether the cohort with this id is being applied. */
+        readonly toggleCohort: FunctionType<[StringType], NullType>;
+        /** Set or clear the group-by dimension. `none` = no breakdown. */
+        readonly setBreakdown: FunctionType<[OptionType<StructType<{
             readonly fieldId: StringType;
             readonly limit: OptionType<IntegerType>;
-        }>>;
-        readonly search: OptionType<StringType>;
-        readonly visible: OptionType<SetType<StringType>>;
-        readonly selectedIndex: OptionType<IntegerType>;
-    }>, ArrayType<"T">, OptionType<FunctionType<["T"], StructType<{
-        readonly id: StringType;
-        readonly label: StringType;
-        readonly meta: OptionType<StringType>;
-    }>>>], StructType<{
+        }>>], NullType>;
+        /** Set the typeahead query. `none` clears; `some("query")` activates it. */
+        readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+        /** Set the visible-series whitelist. `none` = all series visible. */
+        readonly setVisible: FunctionType<[OptionType<SetType<StringType>>], NullType>;
+        /** Set the master-detail selection index. `none` = no selection. */
+        readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
+        /** True when at least one narrowing is active. */
+        readonly isActive: FunctionType<[], BooleanType>;
+        /** Count of currently-applied narrowings — used by `Slice.Summary`. */
+        readonly activeCount: FunctionType<[], IntegerType>;
+        /** Selectable breakdown dimensions for this slice's config → `[{ fieldId, label }]`. */
+        readonly dimensions: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
+            readonly label: StringType;
+        }>>>;
+        /** Every filterable field → `[{ fieldId, label, kind }]`; feeds the predicate builder. */
+        readonly fields: FunctionType<[], ArrayType<StructType<{
+            readonly fieldId: StringType;
+            readonly label: StringType;
+            readonly kind: StringType;
+        }>>>;
+        /** Field ids the typeahead searches over — the chrome rail shows Search when non-empty. */
+        readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+        /** Field id `Slice.Range` narrows on — the chrome rail shows Range when `some`. */
+        readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+        /** Total bound rows, before any narrowing — used by the chrome footer ("N of M"). */
+        readonly totalCount: FunctionType<[], IntegerType>;
+        /** Count of bound rows passing every active narrowing — used by Filter / Summary. */
+        readonly resultCount: FunctionType<[], IntegerType>;
+        /** Active-breakdown series over the bound rows → `[{ key, count }]` — Breakdown / Legend. */
+        readonly groups: FunctionType<[], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly count: IntegerType;
+            readonly color: StringType;
+        }>>>;
+        /**
+         * Pivot the narrowed rows into chart-ready multi-series long format:
+         * grouped by the active breakdown dimension (`key`) and the given x-axis
+         * field, summing the value field → `[{ key, x, value }]`. Feed a
+         * multi-series chart by filtering per (statically-known) series key.
+         * @param xFieldId     - field whose value positions each point on the x-axis
+         * @param valueFieldId - numeric field summed into each point's `value`
+         */
+        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>;
+            }>>;
+        }>>>;
+        /** Typeahead suggestions for the current query (via the bind `toMatch`) → `[{ id, label, meta }]`. */
+        readonly matches: FunctionType<[], ArrayType<StructType<{
+            readonly id: StringType;
+            readonly label: StringType;
+            readonly meta: OptionType<StringType>;
+        }>>>;
+        /** Size of each cohort over the bound rows, keyed by cohort id — Cohort chips. */
+        readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
+    }>>;
+    /** Narrowed rows for a bound slice — the typed data feed (`Slice.rows([RowType], slice)`). */
+    readonly rows: import("@elaraai/east").GenericPlatformDefinition<readonly ["T"], readonly [StructType<{
         /** The store key this slice is bound to — lets renderers self-subscribe. */
         readonly key: StringType;
         /** Read the entire slice state; tracked for reactive re-render. */
@@ -2224,11 +3459,11 @@ export declare const Slice: {
             readonly label: StringType;
             readonly kind: StringType;
         }>>>;
-        /** Field ids the typeahead searches over — `Slice.Frame` shows Search when non-empty. */
+        /** Field ids the typeahead searches over — the chrome rail shows Search when non-empty. */
         readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
-        /** Field id `Slice.Range` narrows on — `Slice.Frame` shows Range when `some`. */
+        /** Field id `Slice.Range` narrows on — the chrome rail shows Range when `some`. */
         readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
-        /** Total bound rows, before any narrowing — used by the `Slice.Frame` footer ("N of M"). */
+        /** Total bound rows, before any narrowing — used by the chrome footer ("N of M"). */
         readonly totalCount: FunctionType<[], IntegerType>;
         /** Count of bound rows passing every active narrowing — used by Filter / Summary. */
         readonly resultCount: FunctionType<[], IntegerType>;
@@ -2250,8 +3485,13 @@ export declare const Slice: {
             readonly key: StringType;
             readonly color: StringType;
             readonly points: ArrayType<StructType<{
-                readonly x: StringType;
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: DateTimeType;
+                }>;
                 readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
             }>>;
         }>>>;
         /** Typeahead suggestions for the current query (via the bind `toMatch`) → `[{ id, label, meta }]`. */
@@ -2262,7 +3502,7 @@ export declare const Slice: {
         }>>>;
         /** Size of each cohort over the bound rows, keyed by cohort id — Cohort chips. */
         readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
-    }>>;
+    }>], ArrayType<"T">>;
     /**
      * Pure narrowing engine. State + config + data → narrowed data.
      * Stateless, deterministic, host-impl-portable.
@@ -3794,11 +5034,11 @@ export declare const Slice: {
                 readonly label: StringType;
                 readonly kind: StringType;
             }>>>;
-            /** Field ids the typeahead searches over — `Slice.Frame` shows Search when non-empty. */
+            /** Field ids the typeahead searches over — the chrome rail shows Search when non-empty. */
             readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
-            /** Field id `Slice.Range` narrows on — `Slice.Frame` shows Range when `some`. */
+            /** Field id `Slice.Range` narrows on — the chrome rail shows Range when `some`. */
             readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
-            /** Total bound rows, before any narrowing — used by the `Slice.Frame` footer ("N of M"). */
+            /** Total bound rows, before any narrowing — used by the chrome footer ("N of M"). */
             readonly totalCount: FunctionType<[], IntegerType>;
             /** Count of bound rows passing every active narrowing — used by Filter / Summary. */
             readonly resultCount: FunctionType<[], IntegerType>;
@@ -3820,8 +5060,13 @@ export declare const Slice: {
                 readonly key: StringType;
                 readonly color: StringType;
                 readonly points: ArrayType<StructType<{
-                    readonly x: StringType;
+                    readonly x: VariantType<{
+                        readonly category: StringType;
+                        readonly number: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
                     readonly value: FloatType;
+                    readonly size: OptionType<FloatType>;
                 }>>;
             }>>>;
             /** Typeahead suggestions for the current query (via the bind `toMatch`) → `[{ id, label, meta }]`. */
@@ -3839,15 +5084,25 @@ export declare const Slice: {
             readonly color: StringType;
         }>;
         readonly SeriesPoint: StructType<{
-            readonly x: StringType;
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: DateTimeType;
+            }>;
             readonly value: FloatType;
+            readonly size: OptionType<FloatType>;
         }>;
         readonly Series: StructType<{
             readonly key: StringType;
             readonly color: StringType;
             readonly points: ArrayType<StructType<{
-                readonly x: StringType;
+                readonly x: VariantType<{
+                    readonly category: StringType;
+                    readonly number: FloatType;
+                    readonly time: DateTimeType;
+                }>;
                 readonly value: FloatType;
+                readonly size: OptionType<FloatType>;
             }>>;
         }>;
         readonly Dimension: StructType<{