@elaraai/e3-ui 1.0.12 → 1.0.14

package/dist/src/experiment/index.d.ts

@@ -6,68 +6,50 @@
  * `Experiment` component — an interactive causal-experiment surface.
  *
  * @remarks
- * `Experiment` lets a domain expert ask *"did X change Y?"* against a dataset
- * and trust the answer, without meeting a statistician's vocabulary. It is a
- * registered extension component (architecturally like {@link Ontology}): the
- * author writes one tag, `Experiment.Root({ … })`; the React renderer lives in
- * `@elaraai/e3-ui-components` and is wired via
- * `implementUIComponent(Experiment.Component, EastChakraExperiment)`.
+ * `Experiment` lets a domain expert ask *"did X change Y, and can I trust it?"*
+ * against a dataset and read a derived, honest answer — without meeting a
+ * statistician's vocabulary. It is a registered extension component
+ * (architecturally like {@link Ontology}): the author writes one tag,
+ * `Experiment.Root({ … })`; the React renderer lives in
+ * `@elaraai/e3-ui-components`.
  *
  * **Generic over the input row, like `Table`.** The author binds the input
- * dataset (`data: BoundValue<ArrayType<Row>>`); the renderer introspects its
- * row struct to drive the treatment / outcome / confounder pickers, so the
- * **end user** re-frames the experiment from the dataset's own columns.
+ * dataset (`data: BoundValue<ArrayType<Row>>`); the renderer introspects its row
+ * struct to drive the treatment / outcome / confounder pickers.
  *
- * **The user adjusts → results go stale → Run re-computes.** Editing a picker
- * stages a new {@link ExperimentSpecType} and marks the result stale; **Run**
- * calls the author-supplied estimator functions ({@link Func.bind} handles) and
- * the answer arrives reactively; **Commit** appends to the journal. The causal
- * compute (DoWhy / EconML) lives entirely in those function bodies, so `e3-ui`
- * never imports `east-py-datascience`.
+ * **The user edits the config → Apply runs ONE function.** Editing a picker
+ * stages a new {@link ExperimentConfigType}; **Apply** calls the single bound
+ * `experiment` function (`(rows, config) → ExperimentResult`) and the answer
+ * arrives reactively. The result carries the naive vs adjusted effect, balance,
+ * overlap, robustness, and an honesty **verdict** — `adjusted` is `none` when the
+ * engine refuses. **Commit** appends to the journal.
  *
- * **Visual-first and derived.** Because the user frames an arbitrary
- * experiment, nothing on the result side is hand-authored — every word is a
- * column name the user picked, a number an estimator returned, or a status
- * derived by rule (interval clears zero → HIGHER / LOWER; spans zero → NO CLEAR
- * EFFECT; raw and adjusted disagree in sign → the "misleading" banner). The
- * contract types ({@link ExperimentSpecType}, {@link ExperimentResultType}, …)
- * live in {@link "./experiment/types"} and are reached via `Experiment.Types.*`.
+ * **Visual-first and derived.** Nothing on the result side is hand-authored —
+ * every word is a column name the user picked, a number the engine returned, or
+ * a status derived by rule from the verdict tag.
  *
  * @packageDocumentation
  */
-import { NullType, BooleanType, StringType, ArrayType, StructType, VariantType, OptionType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
+import { NullType, BooleanType, ArrayType, StructType, VariantType, OptionType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
 import { type UIComponentType } from '@elaraai/east-ui';
-import { type BoundValue } from '../data.js';
-import { type BoundFunc } from '../func.js';
-import { ExperimentSpecType, ExperimentResultType, RefuteResultType, DoseResultType, JournalType } from './types.js';
-export { WeightingSchemeType, EstimatorType, TargetUnitsType, TrimType, ExperimentSpecType, CiType, BalanceRowType, ExperimentResultType, RefuteKindType, RefuteCheckType, RefuteResultType, DoseSegmentType, DoseResultType, JournalRowType, JournalType, ColumnMetaType, } from './types.js';
+import { type BoundValue } from '../bind/data.js';
+import { type BoundFunc } from '../bind/func.js';
+import { ExperimentConfigType, ExperimentResultType, JournalType, PopulationType, DesignConfigType, ExperimentDesignType } from './types.js';
+export { CiType, WeightingSchemeType, EstimatorType, TargetUnitsType, BootstrapConfigType, RefuteSpecType, ExperimentConfigType, BalanceRowType, OverlapDiagnosticType, RefutationType, DoseResponseType, ExperimentVerdictType, ExperimentResultType, JournalRowType, JournalType, ColumnMetaType, PopulationType, } from './types.js';
 /**
- * The `estimate` function signature: `(rows, spec) → ExperimentResult`. The
- * renderer calls this on **Run** with the bound `data` and the staged spec.
+ * The `experiment` function signature: `(rows, config) → ExperimentResult`. The
+ * renderer calls this on **Apply** with the bound `data` and the staged config.
  *
  * @typeParam Row - The input dataset's row struct.
  */
-export type EstimateFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentSpecType], ExperimentResultType>;
-/**
- * The optional `refute` function signature: `(rows, spec) → RefuteResult` — the
- * robustness battery shown in the "Can we trust it?" tab.
- *
- * @typeParam Row - The input dataset's row struct.
- */
-export type RefuteFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentSpecType], RefuteResultType>;
-/**
- * The optional `dose` function signature: `(rows, spec, feature) → DoseResult` —
- * the ALE dose-response curve for the chosen `feature` column shown in the "How
- * much?" tab.
- *
- * @typeParam Row - The input dataset's row struct.
- */
-export type DoseFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentSpecType, StringType], DoseResultType>;
-/** Initial result tab variant — `answer` (default), `trust`, or `dose`. */
+export type ExperimentFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentConfigType], ExperimentResultType>;
+export type ExperimentDesignFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentConfigType, ExperimentResultType, DesignConfigType], ExperimentDesignType>;
+/** Initial result tab variant — `answer` (default), `trust`, `dose`, or `validate`. */
 export declare const ExperimentTabType: VariantType<{
     readonly answer: NullType;
     readonly trust: NullType;
     readonly dose: NullType;
+    readonly validate: NullType;
 }>;
 /** Type alias for {@link ExperimentTabType}. */
 export type ExperimentTabType = typeof ExperimentTabType;
@@ -76,65 +58,75 @@ export type ExperimentTabType = typeof ExperimentTabType;
  * decode this and resolve each binding to a live, reactive value / call handle.
  *
  * @property data - {@link DiffBindingType} for the input dataset — the renderer
- *   introspects its row struct for the pickers and passes it to the functions.
- * @property spec - {@link DiffBindingType} for the staged {@link ExperimentSpecType}.
- * @property estimate - {@link FuncBindingType} for the `estimate` function.
- * @property refute - Optional {@link FuncBindingType} for the `refute` function.
- * @property dose - Optional {@link FuncBindingType} for the `dose` function.
+ *   introspects its row struct for the pickers and passes it to the function.
+ * @property config - {@link DiffBindingType} for the staged {@link ExperimentConfigType}.
+ * @property experiment - {@link FuncBindingType} for the single `experiment` function.
+ * @property population - Optional {@link DiffBindingType} for the staged Step-4
+ *   population filter ({@link PopulationType}); narrows rows UI-side before the call.
  * @property journal - Optional {@link DiffBindingType} for the committed-experiment journal.
  * @property columnMeta - Optional per-column display metadata.
- * @property readonly - Render without the Run / Commit / edit affordances.
+ * @property readonly - Render without the Apply / Commit / edit affordances.
  * @property defaultTab - Initial result tab ({@link ExperimentTabType}).
  */
 export declare const ExperimentPayloadType: StructType<{
     readonly data: StructType<{
         readonly source: ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>;
         readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>>;
         readonly mode: VariantType<{
             readonly staged: NullType;
             readonly direct: NullType;
         }>;
     }>;
-    readonly spec: StructType<{
+    readonly config: StructType<{
         readonly source: ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>;
         readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>>;
         readonly mode: VariantType<{
             readonly staged: NullType;
             readonly direct: NullType;
         }>;
     }>;
-    readonly estimate: StructType<{
-        readonly name: StringType;
+    readonly experiment: StructType<{
+        readonly name: import("@elaraai/east").StringType;
     }>;
-    readonly refute: OptionType<StructType<{
-        readonly name: StringType;
-    }>>;
-    readonly dose: OptionType<StructType<{
-        readonly name: StringType;
+    readonly population: OptionType<StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
     }>>;
     readonly journal: OptionType<StructType<{
         readonly source: ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>;
         readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>>;
         readonly mode: VariantType<{
             readonly staged: NullType;
             readonly direct: NullType;
         }>;
     }>>;
-    readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
-        readonly label: OptionType<StringType>;
-        readonly unit: OptionType<StringType>;
+    /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
+    readonly design: OptionType<StructType<{
+        readonly name: import("@elaraai/east").StringType;
+    }>>;
+    readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
+        readonly label: OptionType<import("@elaraai/east").StringType>;
+        readonly unit: OptionType<import("@elaraai/east").StringType>;
         readonly higherIsBetter: OptionType<BooleanType>;
     }>>>;
     readonly readonly: OptionType<BooleanType>;
@@ -142,12 +134,13 @@ export declare const ExperimentPayloadType: StructType<{
         readonly answer: NullType;
         readonly trust: NullType;
         readonly dose: NullType;
+        readonly validate: NullType;
     }>>;
 }>;
 /** Type alias for {@link ExperimentPayloadType}. */
 export type ExperimentPayloadType = typeof ExperimentPayloadType;
 /** Initial result tab as a string literal. */
-export type ExperimentTabLiteral = 'answer' | 'trust' | 'dose';
+export type ExperimentTabLiteral = 'answer' | 'trust' | 'dose' | 'validate';
 /**
  * Internal {@link EastUI.component} carrier. The React renderer registers
  * against this in `@elaraai/e3-ui-components`.
@@ -155,52 +148,62 @@ export type ExperimentTabLiteral = 'answer' | 'trust' | 'dose';
 export declare const ExperimentComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
     readonly data: StructType<{
         readonly source: ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>;
         readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>>;
         readonly mode: VariantType<{
             readonly staged: NullType;
             readonly direct: NullType;
         }>;
     }>;
-    readonly spec: StructType<{
+    readonly config: StructType<{
         readonly source: ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>;
         readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>>;
         readonly mode: VariantType<{
             readonly staged: NullType;
             readonly direct: NullType;
         }>;
     }>;
-    readonly estimate: StructType<{
-        readonly name: StringType;
+    readonly experiment: StructType<{
+        readonly name: import("@elaraai/east").StringType;
     }>;
-    readonly refute: OptionType<StructType<{
-        readonly name: StringType;
-    }>>;
-    readonly dose: OptionType<StructType<{
-        readonly name: StringType;
+    readonly population: OptionType<StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
     }>>;
     readonly journal: OptionType<StructType<{
         readonly source: ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>;
         readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
+            readonly field: import("@elaraai/east").StringType;
         }>>>;
         readonly mode: VariantType<{
             readonly staged: NullType;
             readonly direct: NullType;
         }>;
     }>>;
-    readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
-        readonly label: OptionType<StringType>;
-        readonly unit: OptionType<StringType>;
+    /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
+    readonly design: OptionType<StructType<{
+        readonly name: import("@elaraai/east").StringType;
+    }>>;
+    readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
+        readonly label: OptionType<import("@elaraai/east").StringType>;
+        readonly unit: OptionType<import("@elaraai/east").StringType>;
         readonly higherIsBetter: OptionType<BooleanType>;
     }>>>;
     readonly readonly: OptionType<BooleanType>;
@@ -208,23 +211,9 @@ export declare const ExperimentComponent: import("@elaraai/east-ui").UIComponent
         readonly answer: NullType;
         readonly trust: NullType;
         readonly dose: NullType;
+        readonly validate: NullType;
     }>>;
 }>>;
-/**
- * Options for {@link Experiment.Root}, generic over the input row struct.
- *
- * @typeParam Row - The input dataset's row struct — inferred from `data`.
- *
- * @property data - The {@link Data.bind} handle for the input dataset.
- * @property spec - The {@link Data.bind} handle for the staged experiment spec.
- * @property estimate - The {@link Func.bind} handle for the estimator.
- * @property refute - Optional {@link Func.bind} handle for the robustness battery.
- * @property dose - Optional {@link Func.bind} handle for the dose-response curve.
- * @property journal - Optional {@link Data.bind} handle for the committed-experiment journal.
- * @property columnMeta - Optional per-column display metadata.
- * @property readonly - Render without mutation affordances.
- * @property defaultTab - Initial result tab.
- */
 /**
  * Per-column display config — the friendly label, unit suffix, and good
  * direction the surface uses to phrase results ("worse" instead of "lower").
@@ -246,12 +235,29 @@ export interface ExperimentColumnConfig {
 export type ExperimentColumns<Row extends StructType> = {
     [K in Extract<keyof Row['fields'], string>]?: ExperimentColumnConfig;
 };
+/**
+ * Options for {@link Experiment.Root}, generic over the input row struct.
+ *
+ * @typeParam Row - The input dataset's row struct — inferred from `data`.
+ *
+ * @property data - The {@link Data.bind} handle for the input dataset.
+ * @property config - The {@link Data.bind} handle for the staged experiment config.
+ * @property experiment - The {@link Func.bind} handle for the experiment function.
+ * @property population - Optional {@link Data.bind} handle for the staged Step-4
+ *   population filter (a {@link PopulationType}); narrows the rows UI-side before
+ *   the call. Bind it (seeded) to start with filters applied.
+ * @property journal - Optional {@link Data.bind} handle for the committed-experiment journal.
+ * @property columns - Optional per-column display config.
+ * @property readonly - Render without mutation affordances.
+ * @property defaultTab - Initial result tab.
+ */
 export interface ExperimentOptions<Row extends StructType> {
     data: BoundValue<ArrayType<Row>>;
-    spec: BoundValue<ExperimentSpecType>;
-    estimate: EstimateFunc<Row>;
-    refute?: RefuteFunc<Row>;
-    dose?: DoseFunc<Row>;
+    config: BoundValue<ExperimentConfigType>;
+    experiment: ExperimentFunc<Row>;
+    /** Optional `design` function — adds the "Validate" tab (the trial recipe). */
+    design?: ExperimentDesignFunc<Row>;
+    population?: BoundValue<PopulationType>;
     journal?: BoundValue<JournalType>;
     /** Per-column display config, keyed by the data row's fields (like `Table`). */
     columns?: ExperimentColumns<Row>;
@@ -259,25 +265,24 @@ export interface ExperimentOptions<Row extends StructType> {
     defaultTab?: ExperimentTabLiteral;
 }
 /**
- * Build an Experiment surface bound to an input dataset + estimator functions.
+ * Build an Experiment surface bound to an input dataset + the single experiment
+ * function.
  *
  * @typeParam Row - The input dataset's row struct, inferred from `data`.
- * @param options - {@link ExperimentOptions}. `data`, `spec` and `estimate` are
- *   required; the rest are optional.
+ * @param options - {@link ExperimentOptions}. `data`, `config` and `experiment`
+ *   are required; the rest are optional.
  * @returns An East expression of {@link UIComponentType}.
  */
 declare function createExperiment<Row extends StructType>(options: ExperimentOptions<Row>): ExprType<UIComponentType>;
 /**
  * The Experiment component namespace. Surfaces an interactive causal-experiment
- * over a bound input dataset + estimator functions, generic over the row struct
- * (the `Table` pattern), with the staged-binding machinery the rest of e3-ui
- * uses.
+ * over a bound input dataset + a single `experiment` function, generic over the
+ * row struct (the `Table` pattern).
  *
  * @remarks
- * Use `Experiment.Root({ data, spec, estimate, refute, dose, journal })` inside
- * a `Reactive` block. The `Component` property is the {@link EastUI.component}
- * carrier the renderer registers against; `Types` exposes the render-contract
- * value types (`Spec`, `Result`, `Refute`, `Dose`, `Journal`, …).
+ * Use `Experiment.Root({ data, config, experiment, journal })` inside a
+ * `Reactive` block. `Types` exposes the render-contract value types (`Config`,
+ * `Result`, `Verdict`, `Overlap`, `Balance`, `Refutation`, `Journal`, …).
  */
 export declare const Experiment: {
     readonly Root: typeof createExperiment;
@@ -285,52 +290,62 @@ export declare const Experiment: {
     readonly Component: import("@elaraai/east-ui").UIComponentDef<StructType<{
         readonly data: StructType<{
             readonly source: ArrayType<VariantType<{
-                readonly field: StringType;
+                readonly field: import("@elaraai/east").StringType;
             }>>;
             readonly patch: OptionType<ArrayType<VariantType<{
-                readonly field: StringType;
+                readonly field: import("@elaraai/east").StringType;
             }>>>;
             readonly mode: VariantType<{
                 readonly staged: NullType;
                 readonly direct: NullType;
             }>;
         }>;
-        readonly spec: StructType<{
+        readonly config: StructType<{
             readonly source: ArrayType<VariantType<{
-                readonly field: StringType;
+                readonly field: import("@elaraai/east").StringType;
             }>>;
             readonly patch: OptionType<ArrayType<VariantType<{
-                readonly field: StringType;
+                readonly field: import("@elaraai/east").StringType;
             }>>>;
             readonly mode: VariantType<{
                 readonly staged: NullType;
                 readonly direct: NullType;
             }>;
         }>;
-        readonly estimate: StructType<{
-            readonly name: StringType;
+        readonly experiment: StructType<{
+            readonly name: import("@elaraai/east").StringType;
         }>;
-        readonly refute: OptionType<StructType<{
-            readonly name: StringType;
-        }>>;
-        readonly dose: OptionType<StructType<{
-            readonly name: StringType;
+        readonly population: OptionType<StructType<{
+            readonly source: ArrayType<VariantType<{
+                readonly field: import("@elaraai/east").StringType;
+            }>>;
+            readonly patch: OptionType<ArrayType<VariantType<{
+                readonly field: import("@elaraai/east").StringType;
+            }>>>;
+            readonly mode: VariantType<{
+                readonly staged: NullType;
+                readonly direct: NullType;
+            }>;
         }>>;
         readonly journal: OptionType<StructType<{
             readonly source: ArrayType<VariantType<{
-                readonly field: StringType;
+                readonly field: import("@elaraai/east").StringType;
             }>>;
             readonly patch: OptionType<ArrayType<VariantType<{
-                readonly field: StringType;
+                readonly field: import("@elaraai/east").StringType;
             }>>>;
             readonly mode: VariantType<{
                 readonly staged: NullType;
                 readonly direct: NullType;
             }>;
         }>>;
-        readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
-            readonly label: OptionType<StringType>;
-            readonly unit: OptionType<StringType>;
+        /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
+        readonly design: OptionType<StructType<{
+            readonly name: import("@elaraai/east").StringType;
+        }>>;
+        readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
+            readonly label: OptionType<import("@elaraai/east").StringType>;
+            readonly unit: OptionType<import("@elaraai/east").StringType>;
             readonly higherIsBetter: OptionType<BooleanType>;
         }>>>;
         readonly readonly: OptionType<BooleanType>;
@@ -338,6 +353,7 @@ export declare const Experiment: {
             readonly answer: NullType;
             readonly trust: NullType;
             readonly dose: NullType;
+            readonly validate: NullType;
         }>>;
     }>>;
     readonly Types: {
@@ -345,52 +361,62 @@ export declare const Experiment: {
         readonly Payload: StructType<{
             readonly data: StructType<{
                 readonly source: ArrayType<VariantType<{
-                    readonly field: StringType;
+                    readonly field: import("@elaraai/east").StringType;
                 }>>;
                 readonly patch: OptionType<ArrayType<VariantType<{
-                    readonly field: StringType;
+                    readonly field: import("@elaraai/east").StringType;
                 }>>>;
                 readonly mode: VariantType<{
                     readonly staged: NullType;
                     readonly direct: NullType;
                 }>;
             }>;
-            readonly spec: StructType<{
+            readonly config: StructType<{
                 readonly source: ArrayType<VariantType<{
-                    readonly field: StringType;
+                    readonly field: import("@elaraai/east").StringType;
                 }>>;
                 readonly patch: OptionType<ArrayType<VariantType<{
-                    readonly field: StringType;
+                    readonly field: import("@elaraai/east").StringType;
                 }>>>;
                 readonly mode: VariantType<{
                     readonly staged: NullType;
                     readonly direct: NullType;
                 }>;
             }>;
-            readonly estimate: StructType<{
-                readonly name: StringType;
+            readonly experiment: StructType<{
+                readonly name: import("@elaraai/east").StringType;
             }>;
-            readonly refute: OptionType<StructType<{
-                readonly name: StringType;
-            }>>;
-            readonly dose: OptionType<StructType<{
-                readonly name: StringType;
+            readonly population: OptionType<StructType<{
+                readonly source: ArrayType<VariantType<{
+                    readonly field: import("@elaraai/east").StringType;
+                }>>;
+                readonly patch: OptionType<ArrayType<VariantType<{
+                    readonly field: import("@elaraai/east").StringType;
+                }>>>;
+                readonly mode: VariantType<{
+                    readonly staged: NullType;
+                    readonly direct: NullType;
+                }>;
             }>>;
             readonly journal: OptionType<StructType<{
                 readonly source: ArrayType<VariantType<{
-                    readonly field: StringType;
+                    readonly field: import("@elaraai/east").StringType;
                 }>>;
                 readonly patch: OptionType<ArrayType<VariantType<{
-                    readonly field: StringType;
+                    readonly field: import("@elaraai/east").StringType;
                 }>>>;
                 readonly mode: VariantType<{
                     readonly staged: NullType;
                     readonly direct: NullType;
                 }>;
             }>>;
-            readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
-                readonly label: OptionType<StringType>;
-                readonly unit: OptionType<StringType>;
+            /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
+            readonly design: OptionType<StructType<{
+                readonly name: import("@elaraai/east").StringType;
+            }>>;
+            readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
+                readonly label: OptionType<import("@elaraai/east").StringType>;
+                readonly unit: OptionType<import("@elaraai/east").StringType>;
                 readonly higherIsBetter: OptionType<BooleanType>;
             }>>>;
             readonly readonly: OptionType<BooleanType>;
@@ -398,65 +424,15 @@ export declare const Experiment: {
                 readonly answer: NullType;
                 readonly trust: NullType;
                 readonly dose: NullType;
+                readonly validate: NullType;
             }>>;
         }>;
-        /** The experiment-spec value type (what the pickers stage). */
-        readonly Spec: StructType<{
-            readonly treatment: StringType;
-            readonly outcome: StringType;
-            readonly confounders: ArrayType<StringType>;
-            readonly categorical: ArrayType<StringType>;
-            readonly population: OptionType<ArrayType<VariantType<{
-                readonly string: import("@elaraai/east").StructType<{
-                    readonly fieldId: import("@elaraai/east").StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly eq: import("@elaraai/east").StringType;
-                        readonly neq: import("@elaraai/east").StringType;
-                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                        readonly contains: import("@elaraai/east").StringType;
-                        readonly matches: import("@elaraai/east").StringType;
-                    }>;
-                }>;
-                readonly integer: import("@elaraai/east").StructType<{
-                    readonly fieldId: import("@elaraai/east").StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly eq: import("@elaraai/east").IntegerType;
-                        readonly neq: import("@elaraai/east").IntegerType;
-                        readonly lt: import("@elaraai/east").IntegerType;
-                        readonly lte: import("@elaraai/east").IntegerType;
-                        readonly gt: import("@elaraai/east").IntegerType;
-                        readonly gte: import("@elaraai/east").IntegerType;
-                        readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                    }>;
-                }>;
-                readonly float: import("@elaraai/east").StructType<{
-                    readonly fieldId: import("@elaraai/east").StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly lt: import("@elaraai/east").FloatType;
-                        readonly lte: import("@elaraai/east").FloatType;
-                        readonly gt: import("@elaraai/east").FloatType;
-                        readonly gte: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                readonly datetime: import("@elaraai/east").StructType<{
-                    readonly fieldId: import("@elaraai/east").StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: import("@elaraai/east").StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: import("@elaraai/east").StructType<{
-                    readonly fieldId: import("@elaraai/east").StringType;
-                    readonly op: import("@elaraai/east").VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>>;
+        /** The experiment-config value type (what the pickers stage). */
+        readonly Config: StructType<{
+            readonly treatment: import("@elaraai/east").StringType;
+            readonly outcome: import("@elaraai/east").StringType;
+            readonly common_causes: ArrayType<import("@elaraai/east").StringType>;
+            readonly categorical: OptionType<ArrayType<import("@elaraai/east").StringType>>;
             readonly method: OptionType<VariantType<{
                 readonly linear_regression: NullType;
                 readonly propensity_score_weighting: StructType<{
@@ -467,131 +443,102 @@ export declare const Experiment: {
                     }>>;
                 }>;
             }>>;
-            readonly targetUnits: OptionType<VariantType<{
+            readonly estimand: OptionType<VariantType<{
                 readonly ate: NullType;
                 readonly att: NullType;
                 readonly atc: NullType;
             }>>;
-            readonly trim: OptionType<VariantType<{
-                readonly overlap: NullType;
-                readonly bounds: StructType<{
-                    readonly lower: import("@elaraai/east").FloatType;
-                    readonly upper: import("@elaraai/east").FloatType;
-                }>;
+            readonly refute: OptionType<StructType<{
+                readonly placebo: BooleanType;
+                readonly random_common_cause: BooleanType;
+                readonly data_subset: BooleanType;
+                readonly sensitivity: OptionType<ArrayType<import("@elaraai/east").FloatType>>;
+            }>>;
+            readonly dose_feature: OptionType<import("@elaraai/east").StringType>;
+            readonly min_overlap: OptionType<import("@elaraai/east").FloatType>;
+            readonly min_treatment_variation: OptionType<import("@elaraai/east").FloatType>;
+            readonly bootstrap: OptionType<StructType<{
+                readonly reps: import("@elaraai/east").IntegerType;
+                readonly cluster_column: OptionType<import("@elaraai/east").StringType>;
+                readonly confidence_level: OptionType<import("@elaraai/east").FloatType>;
             }>>;
+            readonly random_state: OptionType<import("@elaraai/east").IntegerType>;
         }>;
-        /** The estimator answer value type. */
+        /** The result value type (numbers + verdict). */
         readonly Result: StructType<{
-            readonly effect: import("@elaraai/east").FloatType;
-            readonly ci: OptionType<StructType<{
-                readonly lower: import("@elaraai/east").FloatType;
-                readonly upper: import("@elaraai/east").FloatType;
-            }>>;
             readonly naive: import("@elaraai/east").FloatType;
-            readonly naiveCi: OptionType<StructType<{
+            readonly naive_ci: OptionType<StructType<{
                 readonly lower: import("@elaraai/east").FloatType;
                 readonly upper: import("@elaraai/east").FloatType;
             }>>;
-            readonly nTotal: import("@elaraai/east").IntegerType;
-            readonly nTreated: import("@elaraai/east").IntegerType;
-            readonly nControl: import("@elaraai/east").IntegerType;
-            readonly nDropped: import("@elaraai/east").IntegerType;
+            readonly adjusted: OptionType<StructType<{
+                readonly effect: import("@elaraai/east").FloatType;
+                readonly ci: OptionType<StructType<{
+                    readonly lower: import("@elaraai/east").FloatType;
+                    readonly upper: import("@elaraai/east").FloatType;
+                }>>;
+            }>>;
+            readonly n_total: import("@elaraai/east").IntegerType;
+            readonly n_treated: import("@elaraai/east").IntegerType;
+            readonly n_control: import("@elaraai/east").IntegerType;
+            readonly n_dropped: import("@elaraai/east").IntegerType;
             readonly balance: ArrayType<StructType<{
-                readonly column: StringType;
-                readonly treatedMean: import("@elaraai/east").FloatType;
-                readonly controlMean: import("@elaraai/east").FloatType;
-                readonly stdDiff: import("@elaraai/east").FloatType;
+                readonly column: import("@elaraai/east").StringType;
+                readonly base_column: import("@elaraai/east").StringType;
+                readonly treated_mean: import("@elaraai/east").FloatType;
+                readonly control_mean: import("@elaraai/east").FloatType;
+                readonly std_diff: import("@elaraai/east").FloatType;
             }>>;
-        }>;
-        /** The robustness-battery value type. */
-        readonly Refute: StructType<{
-            readonly checks: ArrayType<StructType<{
-                readonly kind: VariantType<{
-                    readonly placebo: NullType;
-                    readonly random_common_cause: NullType;
-                    readonly data_subset: NullType;
-                    readonly unobserved: NullType;
-                }>;
-                readonly estimatedEffect: import("@elaraai/east").FloatType;
-                readonly newEffects: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
-                readonly strengths: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
-                readonly pValue: OptionType<import("@elaraai/east").FloatType>;
+            readonly overlap: StructType<{
+                readonly treated_propensity: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly control_propensity: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly common_support_frac: import("@elaraai/east").FloatType;
+                readonly positivity_ok: BooleanType;
+            }>;
+            readonly refutation: OptionType<StructType<{
+                readonly placebo_effect: OptionType<import("@elaraai/east").FloatType>;
+                readonly placebo_passes: OptionType<BooleanType>;
+                readonly random_cc_within_ci: OptionType<BooleanType>;
+                readonly data_subset_effect: OptionType<import("@elaraai/east").FloatType>;
+                readonly data_subset_std: OptionType<import("@elaraai/east").FloatType>;
+                readonly robustness_value: OptionType<import("@elaraai/east").FloatType>;
+                readonly sensitivity: OptionType<StructType<{
+                    readonly strengths: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                    readonly effects: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                }>>;
+            }>>;
+            readonly dose_response: OptionType<StructType<{
+                readonly feature: import("@elaraai/east").StringType;
+                readonly grid: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly effect: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly lower: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+                readonly upper: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+                readonly size: import("@elaraai/east").VectorType<import("@elaraai/east").IntegerType>;
             }>>;
+            readonly verdict: VariantType<{
+                readonly causal: NullType;
+                readonly modest: NullType;
+                readonly adjustment_insufficient: NullType;
+                readonly non_identifiable_positivity: NullType;
+                readonly not_estimable: import("@elaraai/east").StringType;
+            }>;
         }>;
-        /** The dose-response value type. */
-        readonly Dose: StructType<{
-            readonly feature: StringType;
+        /** The ALE dose-response curve value type (the "How much?" tab). */
+        readonly DoseResponse: StructType<{
+            readonly feature: import("@elaraai/east").StringType;
             readonly grid: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
             readonly effect: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
             readonly lower: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
             readonly upper: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
             readonly size: import("@elaraai/east").VectorType<import("@elaraai/east").IntegerType>;
-            readonly segments: OptionType<ArrayType<StructType<{
-                readonly label: StringType;
-                readonly grid: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
-                readonly effect: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
-                readonly lower: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
-                readonly upper: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
-            }>>>;
         }>;
         /** The committed-experiment journal value type. */
         readonly Journal: ArrayType<StructType<{
-            readonly spec: StructType<{
-                readonly treatment: StringType;
-                readonly outcome: StringType;
-                readonly confounders: ArrayType<StringType>;
-                readonly categorical: ArrayType<StringType>;
-                readonly population: OptionType<ArrayType<VariantType<{
-                    readonly string: import("@elaraai/east").StructType<{
-                        readonly fieldId: import("@elaraai/east").StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").StringType;
-                            readonly neq: import("@elaraai/east").StringType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                            readonly contains: import("@elaraai/east").StringType;
-                            readonly matches: import("@elaraai/east").StringType;
-                        }>;
-                    }>;
-                    readonly integer: import("@elaraai/east").StructType<{
-                        readonly fieldId: import("@elaraai/east").StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly eq: import("@elaraai/east").IntegerType;
-                            readonly neq: import("@elaraai/east").IntegerType;
-                            readonly lt: import("@elaraai/east").IntegerType;
-                            readonly lte: import("@elaraai/east").IntegerType;
-                            readonly gt: import("@elaraai/east").IntegerType;
-                            readonly gte: import("@elaraai/east").IntegerType;
-                            readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: import("@elaraai/east").StructType<{
-                        readonly fieldId: import("@elaraai/east").StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly lt: import("@elaraai/east").FloatType;
-                            readonly lte: import("@elaraai/east").FloatType;
-                            readonly gt: import("@elaraai/east").FloatType;
-                            readonly gte: import("@elaraai/east").FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: import("@elaraai/east").StructType<{
-                        readonly fieldId: import("@elaraai/east").StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: import("@elaraai/east").StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: import("@elaraai/east").StructType<{
-                        readonly fieldId: import("@elaraai/east").StringType;
-                        readonly op: import("@elaraai/east").VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>>;
+            readonly config: StructType<{
+                readonly treatment: import("@elaraai/east").StringType;
+                readonly outcome: import("@elaraai/east").StringType;
+                readonly common_causes: ArrayType<import("@elaraai/east").StringType>;
+                readonly categorical: OptionType<ArrayType<import("@elaraai/east").StringType>>;
                 readonly method: OptionType<VariantType<{
                     readonly linear_regression: NullType;
                     readonly propensity_score_weighting: StructType<{
@@ -602,31 +549,137 @@ export declare const Experiment: {
                         }>>;
                     }>;
                 }>>;
-                readonly targetUnits: OptionType<VariantType<{
+                readonly estimand: OptionType<VariantType<{
                     readonly ate: NullType;
                     readonly att: NullType;
                     readonly atc: NullType;
                 }>>;
-                readonly trim: OptionType<VariantType<{
-                    readonly overlap: NullType;
-                    readonly bounds: StructType<{
-                        readonly lower: import("@elaraai/east").FloatType;
-                        readonly upper: import("@elaraai/east").FloatType;
-                    }>;
+                readonly refute: OptionType<StructType<{
+                    readonly placebo: BooleanType;
+                    readonly random_common_cause: BooleanType;
+                    readonly data_subset: BooleanType;
+                    readonly sensitivity: OptionType<ArrayType<import("@elaraai/east").FloatType>>;
+                }>>;
+                readonly dose_feature: OptionType<import("@elaraai/east").StringType>;
+                readonly min_overlap: OptionType<import("@elaraai/east").FloatType>;
+                readonly min_treatment_variation: OptionType<import("@elaraai/east").FloatType>;
+                readonly bootstrap: OptionType<StructType<{
+                    readonly reps: import("@elaraai/east").IntegerType;
+                    readonly cluster_column: OptionType<import("@elaraai/east").StringType>;
+                    readonly confidence_level: OptionType<import("@elaraai/east").FloatType>;
                 }>>;
+                readonly random_state: OptionType<import("@elaraai/east").IntegerType>;
             }>;
-            readonly effect: import("@elaraai/east").FloatType;
-            readonly ci: OptionType<StructType<{
-                readonly lower: import("@elaraai/east").FloatType;
-                readonly upper: import("@elaraai/east").FloatType;
+            readonly verdict: VariantType<{
+                readonly causal: NullType;
+                readonly modest: NullType;
+                readonly adjustment_insufficient: NullType;
+                readonly non_identifiable_positivity: NullType;
+                readonly not_estimable: import("@elaraai/east").StringType;
+            }>;
+            readonly naive: import("@elaraai/east").FloatType;
+            readonly adjusted: OptionType<import("@elaraai/east").FloatType>;
+            readonly committed_at: import("@elaraai/east").DateTimeType;
+            readonly committed_by: import("@elaraai/east").StringType;
+        }>>;
+        /** The validation-trial recipe value type (the "Validate" tab). */
+        readonly Design: StructType<{
+            readonly verdict: VariantType<{
+                readonly causal: NullType;
+                readonly modest: NullType;
+                readonly adjustment_insufficient: NullType;
+                readonly non_identifiable_positivity: NullType;
+                readonly not_estimable: import("@elaraai/east").StringType;
+            }>;
+            readonly basis: VariantType<{
+                readonly detect_observed: NullType;
+                readonly resolve_vs_null: NullType;
+                readonly de_bias: NullType;
+                readonly restrict_to_overlap: NullType;
+                readonly create_control: NullType;
+            }>;
+            readonly target_effect: import("@elaraai/east").FloatType;
+            readonly outcome_sd: import("@elaraai/east").FloatType;
+            readonly target_power: import("@elaraai/east").FloatType;
+            readonly alpha: import("@elaraai/east").FloatType;
+            readonly current_power: OptionType<import("@elaraai/east").FloatType>;
+            readonly match_on: ArrayType<import("@elaraai/east").StringType>;
+            readonly options: ArrayType<StructType<{
+                readonly label: import("@elaraai/east").StringType;
+                readonly treated_share: import("@elaraai/east").FloatType;
+                readonly n_treated: import("@elaraai/east").IntegerType;
+                readonly n_control: import("@elaraai/east").IntegerType;
+                readonly n_total: import("@elaraai/east").IntegerType;
             }>>;
-            readonly committedAt: import("@elaraai/east").DateTimeType;
-            readonly committedBy: StringType;
+            readonly power_curve: StructType<{
+                readonly n: import("@elaraai/east").VectorType<import("@elaraai/east").IntegerType>;
+                readonly power: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+            }>;
+            readonly rationale: import("@elaraai/east").StringType;
+        }>;
+        /** The optional design-knobs value type. */
+        readonly DesignConfig: StructType<{
+            readonly alpha: OptionType<import("@elaraai/east").FloatType>;
+            readonly target_power: OptionType<import("@elaraai/east").FloatType>;
+            readonly materiality: OptionType<import("@elaraai/east").FloatType>;
+            readonly treated_shares: OptionType<ArrayType<import("@elaraai/east").FloatType>>;
+        }>;
+        /** The UI-side Step-4 population filter value type (Array of Slice predicates). */
+        readonly Population: ArrayType<VariantType<{
+            readonly string: import("@elaraai/east").StructType<{
+                readonly fieldId: import("@elaraai/east").StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly eq: import("@elaraai/east").StringType;
+                    readonly neq: import("@elaraai/east").StringType;
+                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
+                    readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
+                    readonly contains: import("@elaraai/east").StringType;
+                    readonly matches: import("@elaraai/east").StringType;
+                }>;
+            }>;
+            readonly integer: import("@elaraai/east").StructType<{
+                readonly fieldId: import("@elaraai/east").StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly eq: import("@elaraai/east").IntegerType;
+                    readonly neq: import("@elaraai/east").IntegerType;
+                    readonly lt: import("@elaraai/east").IntegerType;
+                    readonly lte: import("@elaraai/east").IntegerType;
+                    readonly gt: import("@elaraai/east").IntegerType;
+                    readonly gte: import("@elaraai/east").IntegerType;
+                    readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
+                }>;
+            }>;
+            readonly float: import("@elaraai/east").StructType<{
+                readonly fieldId: import("@elaraai/east").StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly lt: import("@elaraai/east").FloatType;
+                    readonly lte: import("@elaraai/east").FloatType;
+                    readonly gt: import("@elaraai/east").FloatType;
+                    readonly gte: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            readonly datetime: import("@elaraai/east").StructType<{
+                readonly fieldId: import("@elaraai/east").StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly before: import("@elaraai/east").DateTimeType;
+                    readonly after: import("@elaraai/east").DateTimeType;
+                    readonly between: import("@elaraai/east").StructType<{
+                        readonly from: import("@elaraai/east").DateTimeType;
+                        readonly to: import("@elaraai/east").DateTimeType;
+                    }>;
+                }>;
+            }>;
+            readonly boolean: import("@elaraai/east").StructType<{
+                readonly fieldId: import("@elaraai/east").StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly is: import("@elaraai/east").BooleanType;
+                }>;
+            }>;
         }>>;
         /** Optional per-column display metadata. */
-        readonly ColumnMeta: import("@elaraai/east").DictType<StringType, StructType<{
-            readonly label: OptionType<StringType>;
-            readonly unit: OptionType<StringType>;
+        readonly ColumnMeta: import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
+            readonly label: OptionType<import("@elaraai/east").StringType>;
+            readonly unit: OptionType<import("@elaraai/east").StringType>;
             readonly higherIsBetter: OptionType<BooleanType>;
         }>>;
         /** Initial result tab variant. */
@@ -634,6 +687,7 @@ export declare const Experiment: {
             readonly answer: NullType;
             readonly trust: NullType;
             readonly dose: NullType;
+            readonly validate: NullType;
         }>;
     };
 };