@elaraai/e3-ui 1.0.22 → 1.0.24

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

@@ -34,8 +34,8 @@ import { NullType, BooleanType, ArrayType, StructType, VariantType, OptionType,
 import { type UIComponentType } from '@elaraai/east-ui';
 import { type BoundValue } from '../bind/data.js';
 import { type BoundFunc } from '../bind/func.js';
-import { ExperimentConfigType, ExperimentResultType, JournalType, PopulationType, DesignConfigType, ExperimentDesignType, EstimatorType, TargetUnitsType, BootstrapConfigType, RefuteSpecType, SignType } from './types.js';
-export { CiType, WeightingSchemeType, EstimatorType, TargetUnitsType, BootstrapConfigType, RefuteSpecType, ExperimentConfigType, BalanceRowType, OverlapDiagnosticType, RefutationType, DoseResponseType, ExperimentVerdictType, ExperimentResultType, JournalRowType, JournalType, ColumnMetaType, PopulationType, PresetType, } from './types.js';
+import { ExperimentConfigType, ExperimentResultType, JournalType, ConfigurationType, DesignConfigType, ExperimentDesignType } from './types.js';
+export { CiType, WeightingSchemeType, EstimatorType, TargetUnitsType, BootstrapConfigType, RefuteSpecType, ExperimentConfigType, BalanceRowType, OverlapDiagnosticType, RefutationType, DoseResponseType, ExperimentVerdictType, ExperimentResultType, JournalRowType, JournalType, ColumnMetaType, PopulationType, ConfigurationType, } from './types.js';
 /**
  * The `experiment` function signature: `(rows, config) → ExperimentResult`. The
  * renderer calls this on **Apply** with the bound `data` and the staged config.
@@ -59,11 +59,14 @@ export type ExperimentTabType = typeof ExperimentTabType;
  *
  * @property data - {@link DiffBindingType} for the input dataset — the renderer
  *   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 configs - {@link DiffBindingType} for the list of {@link ConfigurationType}
+ *   questions (each carrying its config + optional precomputed result/design). The
+ *   only config source; selecting one seeds the working config.
+ * @property experiment - Optional {@link FuncBindingType} for the universal estimator
+ *   function; omitted when every shown question carries a precomputed result.
  * @property journal - Optional {@link DiffBindingType} for the committed-experiment journal.
+ * @property design - Optional {@link FuncBindingType} for the universal `design` function
+ *   (the "Validate" tab); applies to any question.
  * @property columnMeta - Optional per-column display metadata.
  * @property readonly - Render without the Apply / Commit / edit affordances.
  * @property defaultTab - Initial result tab ({@link ExperimentTabType}).
@@ -81,7 +84,7 @@ export declare const ExperimentPayloadType: StructType<{
             readonly direct: NullType;
         }>;
     }>;
-    readonly config: StructType<{
+    readonly configs: StructType<{
         readonly source: ArrayType<VariantType<{
             readonly field: import("@elaraai/east").StringType;
         }>>;
@@ -93,20 +96,8 @@ export declare const ExperimentPayloadType: StructType<{
             readonly direct: NullType;
         }>;
     }>;
-    readonly experiment: StructType<{
+    readonly experiment: OptionType<StructType<{
         readonly name: import("@elaraai/east").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<{
@@ -120,7 +111,6 @@ export declare const ExperimentPayloadType: StructType<{
             readonly direct: NullType;
         }>;
     }>>;
-    /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
     readonly design: OptionType<StructType<{
         readonly name: import("@elaraai/east").StringType;
     }>>;
@@ -136,106 +126,6 @@ export declare const ExperimentPayloadType: StructType<{
         readonly dose: NullType;
         readonly validate: NullType;
     }>>;
-    /** Optional developer-authored {@link PresetType} list — named vetted questions
-     *  rendered as a card grid; selecting one snaps the staged spec + scope. */
-    readonly presets: OptionType<ArrayType<StructType<{
-        readonly id: import("@elaraai/east").StringType;
-        readonly label: import("@elaraai/east").StringType;
-        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<{
-                    readonly weighting_scheme: OptionType<VariantType<{
-                        readonly ips_weight: NullType;
-                        readonly ips_stabilized_weight: NullType;
-                        readonly ips_normalized_weight: NullType;
-                    }>>;
-                }>;
-            }>>;
-            readonly estimand: OptionType<VariantType<{
-                readonly ate: NullType;
-                readonly att: NullType;
-                readonly atc: NullType;
-            }>>;
-            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 strong_overlap: OptionType<import("@elaraai/east").FloatType>;
-            readonly evalue_floor: OptionType<import("@elaraai/east").FloatType>;
-            readonly expected_sign: OptionType<VariantType<{
-                readonly positive: NullType;
-                readonly negative: NullType;
-            }>>;
-        }>;
-        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 group: OptionType<import("@elaraai/east").StringType>;
-    }>>>;
 }>;
 /** Type alias for {@link ExperimentPayloadType}. */
 export type ExperimentPayloadType = typeof ExperimentPayloadType;
@@ -258,7 +148,7 @@ export declare const ExperimentComponent: import("@elaraai/east-ui").UIComponent
             readonly direct: NullType;
         }>;
     }>;
-    readonly config: StructType<{
+    readonly configs: StructType<{
         readonly source: ArrayType<VariantType<{
             readonly field: import("@elaraai/east").StringType;
         }>>;
@@ -270,20 +160,8 @@ export declare const ExperimentComponent: import("@elaraai/east-ui").UIComponent
             readonly direct: NullType;
         }>;
     }>;
-    readonly experiment: StructType<{
+    readonly experiment: OptionType<StructType<{
         readonly name: import("@elaraai/east").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<{
@@ -297,7 +175,6 @@ export declare const ExperimentComponent: import("@elaraai/east-ui").UIComponent
             readonly direct: NullType;
         }>;
     }>>;
-    /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
     readonly design: OptionType<StructType<{
         readonly name: import("@elaraai/east").StringType;
     }>>;
@@ -313,106 +190,6 @@ export declare const ExperimentComponent: import("@elaraai/east-ui").UIComponent
         readonly dose: NullType;
         readonly validate: NullType;
     }>>;
-    /** Optional developer-authored {@link PresetType} list — named vetted questions
-     *  rendered as a card grid; selecting one snaps the staged spec + scope. */
-    readonly presets: OptionType<ArrayType<StructType<{
-        readonly id: import("@elaraai/east").StringType;
-        readonly label: import("@elaraai/east").StringType;
-        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<{
-                    readonly weighting_scheme: OptionType<VariantType<{
-                        readonly ips_weight: NullType;
-                        readonly ips_stabilized_weight: NullType;
-                        readonly ips_normalized_weight: NullType;
-                    }>>;
-                }>;
-            }>>;
-            readonly estimand: OptionType<VariantType<{
-                readonly ate: NullType;
-                readonly att: NullType;
-                readonly atc: NullType;
-            }>>;
-            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 strong_overlap: OptionType<import("@elaraai/east").FloatType>;
-            readonly evalue_floor: OptionType<import("@elaraai/east").FloatType>;
-            readonly expected_sign: OptionType<VariantType<{
-                readonly positive: NullType;
-                readonly negative: NullType;
-            }>>;
-        }>;
-        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 group: OptionType<import("@elaraai/east").StringType>;
-    }>>>;
 }>>;
 /**
  * Per-column display config — the friendly label, unit suffix, and good
@@ -435,78 +212,20 @@ export interface ExperimentColumnConfig {
 export type ExperimentColumns<Row extends StructType> = {
     [K in Extract<keyof Row['fields'], string>]?: ExperimentColumnConfig;
 };
-/**
- * A preset's pre-baked experiment config — a friendly, mostly-optional shape over
- * {@link ExperimentConfigType}. The column-bearing fields are checked against the
- * bound row's columns (like {@link ExperimentColumns}); every other field is optional
- * and falls back to the library default (`none`) when omitted, so a preset author
- * writes only what the question actually pins.
- *
- * @typeParam Row - The input dataset's row struct.
- */
-export interface ExperimentPresetConfig<Row extends StructType> {
-    /** Binary treatment column. */
-    treatment: Extract<keyof Row['fields'], string>;
-    /** Outcome column. */
-    outcome: Extract<keyof Row['fields'], string>;
-    /** Confounders to adjust for (the backdoor set). */
-    common_causes: Extract<keyof Row['fields'], string>[];
-    /** Confounder columns holding categories (one-hot encoded). */
-    categorical?: Extract<keyof Row['fields'], string>[];
-    /** Continuous column for the ALE dose-response curve. */
-    dose_feature?: Extract<keyof Row['fields'], string>;
-    /** Estimator (default: linear_regression). */
-    method?: SubtypeExprOrValue<EstimatorType>;
-    /** Target population (default: ate). */
-    estimand?: SubtypeExprOrValue<TargetUnitsType>;
-    /** Which robustness checks to run. */
-    refute?: SubtypeExprOrValue<RefuteSpecType>;
-    /** Bootstrap CI config. */
-    bootstrap?: SubtypeExprOrValue<BootstrapConfigType>;
-    /** Directional prior — flags an implausibly-signed effect. */
-    expected_sign?: SubtypeExprOrValue<SignType>;
-    /** Positivity refuse gate (default 0.10). */
-    min_overlap?: number;
-    /** Not-estimable guard (default 0.02). */
-    min_treatment_variation?: number;
-    /** Strong-overlap gate (default 0.55). */
-    strong_overlap?: number;
-    /** E-value floor (off by default). */
-    evalue_floor?: number;
-    /** Random seed — pin for a reproducible verdict. */
-    random_state?: bigint;
-}
-/**
- * One developer-authored preset for {@link ExperimentOptions.presets} — a named,
- * vetted question (+ optional scope) selectable from the surface's preset grid.
- *
- * @typeParam Row - The input dataset's row struct.
- */
-export interface ExperimentPreset<Row extends StructType> {
-    /** Stable, **unique** id — recorded in the journal and used as the selection
-     *  identity; keep it distinct from `label` so a renamed label never orphans a
-     *  committed row. Two presets must not share an id. */
-    id: string;
-    /** Display title on the card. */
-    label: string;
-    /** The vetted, pre-baked config. */
-    config: ExperimentPresetConfig<Row>;
-    /** Optional population scope applied on select (omit ⇒ clears the scope). */
-    population?: SubtypeExprOrValue<PopulationType>;
-    /** Optional section header — cards sharing a `group` are bucketed together. */
-    group?: string;
-}
 /**
  * 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 configs - The {@link Data.bind} handle for the list of
+ *   {@link ConfigurationType} questions (each carrying its config + optional
+ *   precomputed result/design). The only config source.
+ * @property experiment - Optional {@link Func.bind} handle for the universal
+ *   estimator function; omit when every shown question carries a precomputed result.
+ * @property design - Optional {@link Func.bind} handle for the universal `design`
+ *   function (adds the "Validate" tab); omit when no question needs the trial recipe
+ *   or every shown question carries a precomputed `design`.
  * @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.
@@ -514,27 +233,26 @@ export interface ExperimentPreset<Row extends StructType> {
  */
 export interface ExperimentOptions<Row extends StructType> {
     data: BoundValue<ArrayType<Row>>;
-    config: BoundValue<ExperimentConfigType>;
-    experiment: ExperimentFunc<Row>;
+    /** The questions — and their optional precomputed answers. The only config source. */
+    configs: BoundValue<ArrayType<ConfigurationType>>;
+    /** Optional universal estimator. One function serves every config; omit when every
+     *  shown question carries a precomputed `result`. */
+    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>;
-    readonly?: SubtypeExprOrValue<OptionType<BooleanType>>;
+    readonly?: SubtypeExprOrValue<BooleanType>;
     defaultTab?: ExperimentTabLiteral;
-    /** Developer-authored vetted questions — a card grid that snaps the staged spec
-     *  (and scope) on select. Column fields are checked against the row's columns. */
-    presets?: Array<ExperimentPreset<Row>>;
 }
 /**
  * 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`, `config` and `experiment`
- *   are required; the rest are optional.
+ * @param options - {@link ExperimentOptions}. `data` and `configs` are required;
+ *   the rest are optional.
  * @returns An East expression of {@link UIComponentType}.
  */
 declare function createExperiment<Row extends StructType>(options: ExperimentOptions<Row>): ExprType<UIComponentType>;
@@ -564,7 +282,7 @@ export declare const Experiment: {
                 readonly direct: NullType;
             }>;
         }>;
-        readonly config: StructType<{
+        readonly configs: StructType<{
             readonly source: ArrayType<VariantType<{
                 readonly field: import("@elaraai/east").StringType;
             }>>;
@@ -576,20 +294,8 @@ export declare const Experiment: {
                 readonly direct: NullType;
             }>;
         }>;
-        readonly experiment: StructType<{
+        readonly experiment: OptionType<StructType<{
             readonly name: import("@elaraai/east").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<{
@@ -603,7 +309,6 @@ export declare const Experiment: {
                 readonly direct: NullType;
             }>;
         }>>;
-        /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
         readonly design: OptionType<StructType<{
             readonly name: import("@elaraai/east").StringType;
         }>>;
@@ -619,106 +324,6 @@ export declare const Experiment: {
             readonly dose: NullType;
             readonly validate: NullType;
         }>>;
-        /** Optional developer-authored {@link PresetType} list — named vetted questions
-         *  rendered as a card grid; selecting one snaps the staged spec + scope. */
-        readonly presets: OptionType<ArrayType<StructType<{
-            readonly id: import("@elaraai/east").StringType;
-            readonly label: import("@elaraai/east").StringType;
-            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<{
-                        readonly weighting_scheme: OptionType<VariantType<{
-                            readonly ips_weight: NullType;
-                            readonly ips_stabilized_weight: NullType;
-                            readonly ips_normalized_weight: NullType;
-                        }>>;
-                    }>;
-                }>>;
-                readonly estimand: OptionType<VariantType<{
-                    readonly ate: NullType;
-                    readonly att: NullType;
-                    readonly atc: NullType;
-                }>>;
-                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 strong_overlap: OptionType<import("@elaraai/east").FloatType>;
-                readonly evalue_floor: OptionType<import("@elaraai/east").FloatType>;
-                readonly expected_sign: OptionType<VariantType<{
-                    readonly positive: NullType;
-                    readonly negative: NullType;
-                }>>;
-            }>;
-            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 group: OptionType<import("@elaraai/east").StringType>;
-        }>>>;
     }>>;
     readonly Types: {
         /** Rendered payload struct (bindings + options). */
@@ -735,7 +340,7 @@ export declare const Experiment: {
                     readonly direct: NullType;
                 }>;
             }>;
-            readonly config: StructType<{
+            readonly configs: StructType<{
                 readonly source: ArrayType<VariantType<{
                     readonly field: import("@elaraai/east").StringType;
                 }>>;
@@ -747,20 +352,8 @@ export declare const Experiment: {
                     readonly direct: NullType;
                 }>;
             }>;
-            readonly experiment: StructType<{
+            readonly experiment: OptionType<StructType<{
                 readonly name: import("@elaraai/east").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<{
@@ -774,7 +367,6 @@ export declare const Experiment: {
                     readonly direct: NullType;
                 }>;
             }>>;
-            /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
             readonly design: OptionType<StructType<{
                 readonly name: import("@elaraai/east").StringType;
             }>>;
@@ -790,106 +382,6 @@ export declare const Experiment: {
                 readonly dose: NullType;
                 readonly validate: NullType;
             }>>;
-            /** Optional developer-authored {@link PresetType} list — named vetted questions
-             *  rendered as a card grid; selecting one snaps the staged spec + scope. */
-            readonly presets: OptionType<ArrayType<StructType<{
-                readonly id: import("@elaraai/east").StringType;
-                readonly label: import("@elaraai/east").StringType;
-                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<{
-                            readonly weighting_scheme: OptionType<VariantType<{
-                                readonly ips_weight: NullType;
-                                readonly ips_stabilized_weight: NullType;
-                                readonly ips_normalized_weight: NullType;
-                            }>>;
-                        }>;
-                    }>>;
-                    readonly estimand: OptionType<VariantType<{
-                        readonly ate: NullType;
-                        readonly att: NullType;
-                        readonly atc: NullType;
-                    }>>;
-                    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 strong_overlap: OptionType<import("@elaraai/east").FloatType>;
-                    readonly evalue_floor: OptionType<import("@elaraai/east").FloatType>;
-                    readonly expected_sign: OptionType<VariantType<{
-                        readonly positive: NullType;
-                        readonly negative: NullType;
-                    }>>;
-                }>;
-                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 group: OptionType<import("@elaraai/east").StringType>;
-            }>>>;
         }>;
         /** The experiment-config value type (what the pickers stage). */
         readonly Config: StructType<{
@@ -1219,11 +711,11 @@ export declare const Experiment: {
                 }>;
             }>;
         }>>;
-        /** The developer-authored preset value type (named vetted question + scope). */
-        readonly Preset: StructType<{
+        /** A configuration value type — a named question + scope + optional precomputed answer. */
+        readonly Configuration: StructType<{
             readonly id: import("@elaraai/east").StringType;
             readonly label: import("@elaraai/east").StringType;
-            readonly config: StructType<{
+            readonly spec: StructType<{
                 readonly treatment: import("@elaraai/east").StringType;
                 readonly outcome: import("@elaraai/east").StringType;
                 readonly common_causes: ArrayType<import("@elaraai/east").StringType>;
@@ -1317,6 +809,104 @@ export declare const Experiment: {
                 }>;
             }>>>;
             readonly group: OptionType<import("@elaraai/east").StringType>;
+            readonly result: OptionType<StructType<{
+                readonly naive: import("@elaraai/east").FloatType;
+                readonly naive_ci: OptionType<StructType<{
+                    readonly lower: import("@elaraai/east").FloatType;
+                    readonly upper: import("@elaraai/east").FloatType;
+                }>>;
+                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: 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;
+                }>>;
+                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 support_strength: VariantType<{
+                        readonly refused: NullType;
+                        readonly thin: NullType;
+                        readonly strong: NullType;
+                    }>;
+                }>;
+                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 expected_sign_ok: OptionType<BooleanType>;
+                }>>;
+                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;
+                }>;
+            }>>;
+            readonly design: OptionType<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 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;
+            }>>;
         }>;
         /** Optional per-column display metadata. */
         readonly ColumnMeta: import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{