@elaraai/e3-ui-components 1.0.12 → 1.0.14

package/dist/index.cjs

@@ -2106,9 +2106,6 @@ function datasetCacheKey(workspace, path2) {
   const pathStr = datasetPathToString(path2);
   return pathStr ? `${workspace}.${pathStr}` : workspace;
 }
-function toTreePath(path2) {
-  return path2;
-}
 class ReactiveDatasetCache {
   constructor(config2, api3, clock2 = realClock) {
     __publicField(this, "destroyed", false);
@@ -2230,7 +2227,7 @@ class ReactiveDatasetCache {
     const prevTail = this.writeChains.get(key) ?? Promise.resolve();
     const run = prevTail.then(async () => {
       try {
-        await this.api.set(workspace, toTreePath(path2), value);
+        await this.api.set(workspace, path2, value);
         if (this.destroyed) return;
         this.writeBaselines.set(key, {
           value,
@@ -2285,6 +2282,14 @@ class ReactiveDatasetCache {
     if (this.destroyed) return;
     await this.api.launchDataflow(workspace);
   }
+  /**
+   * Launch a workspace dataflow run without writing first. The standalone
+   * half of {@link writeAndStart}; see the interface doc for semantics.
+   */
+  async launchDataflow(workspace) {
+    if (this.destroyed) return;
+    await this.api.launchDataflow(workspace);
+  }
   /**
    * Preload a dataset into cache. Concurrent preloads of the same key
    * share one fetch (query-core dedup); a write racing the fetch cancels
@@ -2300,7 +2305,7 @@ class ReactiveDatasetCache {
       await this.client.fetchQuery({
         queryKey,
         queryFn: async () => {
-          const result = await this.fetchDataset(workspace, path2);
+          const result = await this.api.get(workspace, path2);
           fetchedHash = result.hash;
           return result.data;
         }
@@ -2316,14 +2321,11 @@ class ReactiveDatasetCache {
     this.knownHashes.set(key, fetchedHash);
     this.notifyChange(key);
   }
-  fetchDataset(workspace, path2) {
-    return this.api.get(workspace, toTreePath(path2));
-  }
   /**
    * List fields at a path. Empty path lists workspace root.
    */
   list(workspace, path2) {
-    return path2.length === 0 ? this.api.listRoot(workspace) : this.api.listAt(workspace, toTreePath(path2));
+    return path2.length === 0 ? this.api.listRoot(workspace) : this.api.listAt(workspace, path2);
   }
   /**
    * Set refetch interval for a dataset (polling).
@@ -2379,6 +2381,11 @@ class ReactiveDatasetCache {
       this.workspacePollers.delete(workspace);
     }
   }
+  refresh(workspace) {
+    if (this.destroyed) return Promise.resolve();
+    if (!this.workspacePollers.has(workspace)) return Promise.resolve();
+    return this.pollWorkspaceStatus(workspace);
+  }
   /**
    * Poll workspace status and reconcile the cache with the server.
    * Concurrent calls for the same workspace dedupe to a single fetch.
@@ -2443,7 +2450,7 @@ class ReactiveDatasetCache {
     if (pending.length === 0) return;
     const fetched = await Promise.allSettled(
       pending.map(
-        (p2) => p2.kind === "fetch" ? this.fetchDataset(workspace, p2.path).then((result) => ({ p: p2, result })) : Promise.resolve({ p: p2, result: null })
+        (p2) => p2.kind === "fetch" ? this.api.get(workspace, p2.path).then((result) => ({ p: p2, result })) : Promise.resolve({ p: p2, result: null })
       )
     );
     if (this.destroyed) return;
@@ -2626,6 +2633,9 @@ class IndexedDBStagedAdapter {
         req.onerror = () => reject2(req.error);
         req.onblocked = () => reject2(new Error("IndexedDB open blocked"));
       });
+      void this.dbPromise.catch(() => {
+        this.dbPromise = null;
+      });
     }
     return this.dbPromise;
   }
@@ -2701,6 +2711,11 @@ class StagedStore {
     __publicField(this, "adapter");
     __publicField(this, "hydrated");
     __publicField(this, "inFlight", /* @__PURE__ */ new Set());
+    // Per-key persistence chain — serializes save/remove for a key so they
+    // land in IndexedDB in call order (last write wins) instead of racing.
+    __publicField(this, "saveChains", /* @__PURE__ */ new Map());
+    // Listeners notified when a persistence op fails durably.
+    __publicField(this, "errorListeners", /* @__PURE__ */ new Set());
     this.adapter = adapter;
     this.hydrated = this.hydrate();
   }
@@ -2737,14 +2752,14 @@ class StagedStore {
       snapshot: next2.snapshot,
       buffered: next2.buffered
     };
-    this.track(this.adapter.save(key, persisted));
+    this.persist(key, () => this.adapter.save(key, persisted));
   }
   discard(workspace, path2) {
     const key = datasetCacheKey(workspace, path2);
     if (!this.entries.has(key)) return false;
     this.entries.delete(key);
     this.notify(key);
-    this.track(this.adapter.remove(key));
+    this.persist(key, () => this.adapter.remove(key));
     return true;
   }
   listKeys() {
@@ -2765,11 +2780,18 @@ class StagedStore {
   getKeyVersion(key) {
     return this.versions.get(key) ?? 0;
   }
+  onPersistError(cb) {
+    this.errorListeners.add(cb);
+    return () => {
+      this.errorListeners.delete(cb);
+    };
+  }
   /** Test-only: clear in-memory + persisted state. */
   async clear() {
     const keys = [...this.entries.keys()];
     this.entries.clear();
     for (const key of keys) this.notify(key);
+    await this.flushPending();
     await this.adapter.clear();
   }
   // ----- internals -------------------------------------------------------
@@ -2778,20 +2800,45 @@ class StagedStore {
     const subs = this.subscribers.get(key);
     if (subs) for (const cb of subs) cb();
   }
-  track(p2) {
-    const wrapped = p2.catch((err) => {
-      console.warn("[StagedStore] persistence operation failed:", err);
-    }).then(() => {
-      this.inFlight.delete(wrapped);
+  /**
+   * Serialize a persistence op behind any prior op for the same key, so they
+   * land in IndexedDB in call order (last write wins) rather than racing.
+   * Tracks the op for {@link flushPending} and routes failures to
+   * {@link onPersistError} listeners (falling back to a console warning).
+   */
+  persist(key, op) {
+    const prev2 = this.saveChains.get(key) ?? Promise.resolve();
+    const settled = prev2.then(op, op).then(
+      () => void 0,
+      (err) => {
+        this.emitPersistError(key, err);
+      }
+    ).then(() => {
+      if (this.saveChains.get(key) === settled) this.saveChains.delete(key);
+      this.inFlight.delete(settled);
     });
-    this.inFlight.add(wrapped);
+    this.saveChains.set(key, settled);
+    this.inFlight.add(settled);
+  }
+  emitPersistError(key, err) {
+    if (this.errorListeners.size === 0) {
+      console.warn("[StagedStore] persistence operation failed:", err);
+      return;
+    }
+    for (const cb of [...this.errorListeners]) {
+      try {
+        cb(key, err);
+      } catch (listenerErr) {
+        console.warn("[StagedStore] persist-error listener threw:", listenerErr);
+      }
+    }
   }
   async hydrate() {
     let persisted;
     try {
       persisted = await this.adapter.loadAll();
     } catch (err) {
-      console.warn("[StagedStore] hydrate failed:", err);
+      this.emitPersistError("", err);
       return;
     }
     for (const [key, p2] of persisted) {
@@ -2827,7 +2874,7 @@ function clearStagedStoreSingleton() {
 }
 const UNCHANGED_VARIANT = east.variant("unchanged", null);
 const blobEqual = east.equalFor(east.BlobType);
-const eastTypeEqual$1 = east.equalFor(internal$1.EastTypeType);
+const eastTypeEqual$2 = east.equalFor(internal$1.EastTypeType);
 const helpersCache = new east.SortedMap(
   void 0,
   east.compareFor(internal$1.EastTypeType)
@@ -2880,6 +2927,7 @@ class BindRuntime {
     // List cache helpers.
     __publicField(this, "listCache", /* @__PURE__ */ new Map());
     this.staged = staged;
+    this.staged.onPersistError((_key, err) => this.emitWriteError(err));
   }
   // ----- cache singleton ------------------------------------------------
   /** Read the active cache. Throws if none has been initialized. */
@@ -2917,6 +2965,16 @@ class BindRuntime {
       this.writeErrorListeners.delete(cb);
     };
   }
+  /** Fan a write/persistence error out to every registered listener. */
+  emitWriteError(error3) {
+    for (const cb of this.writeErrorListeners) {
+      try {
+        cb(error3);
+      } catch (cbErr) {
+        console.error("Data.bind write-error listener threw:", cbErr);
+      }
+    }
+  }
   /** Resolve once every currently-queued write has finished
    *  (success or failure). Errors are NOT thrown — subscribe via
    *  {@link onWriteError} for those. */
@@ -2954,13 +3012,7 @@ class BindRuntime {
         await writeFn();
       } catch (error3) {
         console.error("Data.bind write failed:", error3);
-        for (const cb of this.writeErrorListeners) {
-          try {
-            cb(error3);
-          } catch (cbErr) {
-            console.error("Data.bind write-error listener threw:", cbErr);
-          }
-        }
+        this.emitWriteError(error3);
       }
     }
     this.isProcessingWrites = false;
@@ -3017,7 +3069,7 @@ class BindRuntime {
         return;
       }
       const shapeChanged = existing.mode !== info.mode || existing.hasPatchDataset !== info.hasPatchDataset;
-      const typeChanged = !eastTypeEqual$1(existing.sourceType, info.sourceType);
+      const typeChanged = !eastTypeEqual$2(existing.sourceType, info.sourceType);
       if (!shapeChanged && !typeChanged) {
         this.bindingRegistry.set(key, info);
         return;
@@ -3120,6 +3172,10 @@ class BindRuntime {
       }
       return null;
     };
+    const startLaunch = () => {
+      this.queueWrite(() => cache3.launchDataflow(ws));
+      return null;
+    };
     if (mode === "direct" && !patchPath) {
       return {
         read: () => {
@@ -3134,6 +3190,7 @@ class BindRuntime {
           this.queueWrite(() => cache3.writeAndStart(ws, sourcePath, encodeT(value)));
           return null;
         },
+        start: startLaunch,
         source: () => {
           this.trackPath(ws, sourcePath);
           return readSourceValue();
@@ -3167,6 +3224,7 @@ class BindRuntime {
           this.queueWrite(() => cache3.writeAndStart(ws, pPath2, encodePatch(next2)));
           return null;
         },
+        start: startLaunch,
         source: () => {
           this.trackPath(ws, sourcePath);
           return readSourceValue();
@@ -3180,12 +3238,8 @@ class BindRuntime {
           const patchVal = readPatchValue();
           this.queueWrite(async () => {
             const next2 = apply2(sourceVal, patchVal);
-            const writes = [];
-            cache3.batch(() => {
-              writes.push(cache3.write(ws, sourcePath, encodeT(next2)));
-              writes.push(cache3.write(ws, pPath2, encodePatch(UNCHANGED_VARIANT)));
-            });
-            await Promise.all(writes);
+            await cache3.write(ws, sourcePath, encodeT(next2));
+            await cache3.write(ws, pPath2, encodePatch(UNCHANGED_VARIANT));
           });
           return null;
         },
@@ -3211,6 +3265,7 @@ class BindRuntime {
         },
         write: writeStaged,
         writeAndStart: writeStaged,
+        start: startLaunch,
         source: () => {
           this.trackPath(ws, sourcePath);
           return readSourceValue();
@@ -3255,6 +3310,7 @@ class BindRuntime {
       },
       write: writeStaged,
       writeAndStart: writeStaged,
+      start: startLaunch,
       source: () => {
         this.trackPath(ws, sourcePath);
         return readSourceValue();
@@ -3403,6 +3459,110 @@ platform.registerReactiveTracker({
   }
 });
 platform.registerPlatformImplementation(BindPlatform);
+class TrackedChannelStore {
+  constructor() {
+    __publicField(this, "entries", /* @__PURE__ */ new Map());
+    // Per-key reactive subscription shim.
+    __publicField(this, "keySubscribers", /* @__PURE__ */ new Map());
+    __publicField(this, "keyVersions", /* @__PURE__ */ new Map());
+    // Reactive tracking — read closures push their channel keys here while a
+    // Reactive.Root render is being tracked.
+    __publicField(this, "trackingContext", null);
+  }
+  // ----- reactive tracking ----------------------------------------------
+  enableTracking() {
+    this.trackingContext = /* @__PURE__ */ new Set();
+    return this.trackingContext;
+  }
+  disableTracking() {
+    const keys = this.trackingContext ? [...this.trackingContext] : [];
+    this.trackingContext = null;
+    return keys;
+  }
+  isTracking() {
+    return this.trackingContext !== null;
+  }
+  /** Record a channel-key dependency for the current render (no-op when not
+   *  tracking). */
+  track(key) {
+    var _a2;
+    (_a2 = this.trackingContext) == null ? void 0 : _a2.add(key);
+  }
+  // ----- subscription shim ------------------------------------------------
+  subscribe(key, callback) {
+    let subs = this.keySubscribers.get(key);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.keySubscribers.set(key, subs);
+    }
+    subs.add(callback);
+    return () => {
+      subs.delete(callback);
+      if (subs.size === 0 && this.keySubscribers.get(key) === subs) {
+        this.keySubscribers.delete(key);
+      }
+    };
+  }
+  getKeyVersion(key) {
+    return this.keyVersions.get(key) ?? 0;
+  }
+  notify(key) {
+    this.keyVersions.set(key, (this.keyVersions.get(key) ?? 0) + 1);
+    const subs = this.keySubscribers.get(key);
+    if (subs) for (const cb of [...subs]) cb();
+  }
+  // ----- channel registry + latest-wins latch ----------------------------
+  entry(key) {
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = this.createEntry();
+      this.entries.set(key, entry);
+    }
+    return entry;
+  }
+  /**
+   * Open a latest-wins launch on a channel: bump the seq, mark the entry
+   * `running`, optionally `reset` it (e.g. clear a prior error), notify, and
+   * return a `settle` that applies a terminal mutation only if this launch is
+   * still the current one (a superseded / cancelled launch settles to a
+   * no-op).
+   */
+  beginLaunch(key, reset2) {
+    const entry = this.entry(key);
+    entry.launchSeq += 1;
+    const mySeq = entry.launchSeq;
+    entry.status = "running";
+    reset2 == null ? void 0 : reset2(entry);
+    this.notify(key);
+    const settle = (mutate) => {
+      const current = this.entries.get(key);
+      if (!current || current.launchSeq !== mySeq) return;
+      mutate(current);
+      this.notify(key);
+    };
+    return { entry, settle };
+  }
+  /**
+   * Client-side cancel: if the channel is running, orphan the in-flight wait
+   * (bump the seq) and mark it `cancelled`. `after` runs before the notify,
+   * for subclass-specific cleanup (e.g. dropping an in-flight handle).
+   */
+  cancelChannel(key, after) {
+    const entry = this.entries.get(key);
+    if (entry && entry.status === "running") {
+      entry.launchSeq += 1;
+      entry.status = "cancelled";
+      after == null ? void 0 : after(entry);
+      this.notify(key);
+    }
+  }
+  /** Drop all channel state (entries + subscriptions + versions). */
+  clearChannels() {
+    this.entries.clear();
+    this.keySubscribers.clear();
+    this.keyVersions.clear();
+  }
+}
 function createDefaultFunctionApi(apiUrl, repo, getToken) {
   const opts = () => ({ token: getToken() });
   return {
@@ -3418,8 +3578,8 @@ function createDefaultFunctionApi(apiUrl, repo, getToken) {
     }
   };
 }
-const eastTypeEqual = east.equalFor(internal$1.EastTypeType);
-function signatureOfHandleType(handleType) {
+const eastTypeEqual$1 = east.equalFor(internal$1.EastTypeType);
+function signatureOfFuncHandleType(handleType) {
   var _a2, _b2;
   if (handleType.type !== "Struct") {
     throw new Error(`Func.bind: handle type must be a Struct; got ${handleType.type}`);
@@ -3478,10 +3638,10 @@ function errorOfExecuteResult(result) {
         stderr: result.stderr
       };
     default:
-      return transportError(`unexpected outcome "${outcome.type}"`);
+      return transportError$1(`unexpected outcome "${outcome.type}"`);
   }
 }
-function transportError(message) {
+function transportError$1(message) {
   return {
     kind: east.variant("transport", { message }),
     message,
@@ -3492,20 +3652,16 @@ function transportError(message) {
 function funcChannelKey(workspace, name) {
   return `func:${workspace}:${name}`;
 }
-class FuncRuntime {
+class FuncRuntime extends TrackedChannelStore {
   constructor() {
+    super(...arguments);
     __publicField(this, "api", null);
     __publicField(this, "workspace", null);
-    __publicField(this, "entries", /* @__PURE__ */ new Map());
     // Signature lists are fetched once per workspace and cached.
     __publicField(this, "signatureLists", /* @__PURE__ */ new Map());
-    // Subscription shim — same contract (and the same stale-disposer
-    // guard) as the dataset cache's.
-    __publicField(this, "keySubscribers", /* @__PURE__ */ new Map());
-    __publicField(this, "keyVersions", /* @__PURE__ */ new Map());
-    // Reactive tracking — read closures push their channel keys here while
-    // a Reactive.Root render is being tracked.
-    __publicField(this, "trackingContext", null);
+  }
+  createEntry() {
+    return { status: "idle", launchSeq: 0 };
   }
   // ----- wiring ----------------------------------------------------------
   /** Install the API adapter + workspace — called by the React provider
@@ -3518,59 +3674,8 @@ class FuncRuntime {
   clear() {
     this.api = null;
     this.workspace = null;
-    this.entries.clear();
+    this.clearChannels();
     this.signatureLists.clear();
-    this.keySubscribers.clear();
-    this.keyVersions.clear();
-  }
-  // ----- reactive tracking ----------------------------------------------
-  enableTracking() {
-    this.trackingContext = /* @__PURE__ */ new Set();
-    return this.trackingContext;
-  }
-  disableTracking() {
-    const keys = this.trackingContext ? [...this.trackingContext] : [];
-    this.trackingContext = null;
-    return keys;
-  }
-  isTracking() {
-    return this.trackingContext !== null;
-  }
-  track(key) {
-    var _a2;
-    (_a2 = this.trackingContext) == null ? void 0 : _a2.add(key);
-  }
-  // ----- subscription shim ------------------------------------------------
-  subscribe(key, callback) {
-    let subs = this.keySubscribers.get(key);
-    if (!subs) {
-      subs = /* @__PURE__ */ new Set();
-      this.keySubscribers.set(key, subs);
-    }
-    subs.add(callback);
-    return () => {
-      subs.delete(callback);
-      if (subs.size === 0 && this.keySubscribers.get(key) === subs) {
-        this.keySubscribers.delete(key);
-      }
-    };
-  }
-  getKeyVersion(key) {
-    return this.keyVersions.get(key) ?? 0;
-  }
-  notify(key) {
-    this.keyVersions.set(key, (this.keyVersions.get(key) ?? 0) + 1);
-    const subs = this.keySubscribers.get(key);
-    if (subs) for (const cb of [...subs]) cb();
-  }
-  // ----- registry ----------------------------------------------------------
-  entry(key) {
-    let entry = this.entries.get(key);
-    if (!entry) {
-      entry = { status: "idle", launchSeq: 0 };
-      this.entries.set(key, entry);
-    }
-    return entry;
   }
   /** The deployed signature list for a workspace (fetched once). */
   signatures(workspace) {
@@ -3593,7 +3698,7 @@ class FuncRuntime {
     try {
       list = await this.signatures(workspace);
     } catch (err) {
-      return transportError(`failed to list workspace functions: ${err instanceof Error ? err.message : String(err)}`);
+      return transportError$1(`failed to list workspace functions: ${err instanceof Error ? err.message : String(err)}`);
     }
     const deployed = list.find((f2) => f2.name === name);
     if (!deployed) {
@@ -3604,8 +3709,8 @@ class FuncRuntime {
         stderr: ""
       };
     }
-    const inputsMatch = deployed.inputTypes.length === sig.inputs.length && deployed.inputTypes.every((t4, i) => eastTypeEqual(t4, sig.inputs[i]));
-    const outputMatches = eastTypeEqual(deployed.outputType, sig.output);
+    const inputsMatch = deployed.inputTypes.length === sig.inputs.length && deployed.inputTypes.every((t4, i) => eastTypeEqual$1(t4, sig.inputs[i]));
+    const outputMatches = eastTypeEqual$1(deployed.outputType, sig.output);
     if (!inputsMatch || !outputMatches) {
       const message = `signature mismatch for "${name}": bound (${sig.inputs.length} inputs) disagrees with the deployed package`;
       return {
@@ -3620,17 +3725,7 @@ class FuncRuntime {
   // ----- closure semantics -------------------------------------------------
   launch(workspace, name, sig, args) {
     const key = funcChannelKey(workspace, name);
-    const entry = this.entry(key);
-    entry.launchSeq += 1;
-    const mySeq = entry.launchSeq;
-    entry.status = "running";
-    this.notify(key);
-    const settle = (mutate) => {
-      const current = this.entries.get(key);
-      if (!current || current.launchSeq !== mySeq) return;
-      mutate(current);
-      this.notify(key);
-    };
+    const { settle } = this.beginLaunch(key);
     void (async () => {
       const invalid = await this.validate(workspace, name, sig);
       if (invalid) {
@@ -3644,7 +3739,7 @@ class FuncRuntime {
       if (!api3) {
         settle((e3) => {
           e3.status = "failed";
-          e3.error = transportError("no FunctionApi installed");
+          e3.error = transportError$1("no FunctionApi installed");
         });
         return;
       }
@@ -3655,7 +3750,7 @@ class FuncRuntime {
       } catch (err) {
         settle((e3) => {
           e3.status = "failed";
-          e3.error = transportError(err instanceof Error ? err.message : String(err));
+          e3.error = transportError$1(err instanceof Error ? err.message : String(err));
         });
         return;
       }
@@ -3666,7 +3761,7 @@ class FuncRuntime {
         } catch (err) {
           settle((e3) => {
             e3.status = "failed";
-            e3.error = transportError(`failed to decode result: ${err instanceof Error ? err.message : String(err)}`);
+            e3.error = transportError$1(`failed to decode result: ${err instanceof Error ? err.message : String(err)}`);
           });
           return;
         }
@@ -3686,7 +3781,7 @@ class FuncRuntime {
   }
   /** Build the handle value for one `Func.bind` platform evaluation. */
   buildHandle(handleType, name) {
-    const sig = signatureOfHandleType(handleType);
+    const sig = signatureOfFuncHandleType(handleType);
     const runtime = this;
     const resolveWorkspace = () => {
       if (!runtime.workspace) {
@@ -3724,12 +3819,8 @@ class FuncRuntime {
         return entry.status === "running";
       },
       cancel: () => {
-        const { key, entry } = channel();
-        if (entry.status === "running") {
-          entry.launchSeq += 1;
-          entry.status = "cancelled";
-          runtime.notify(key);
-        }
+        const { key } = channel();
+        runtime.cancelChannel(key);
         return null;
       },
       binding: { name }
@@ -7464,6 +7555,435 @@ var faArrowDown = {
   iconName: "arrow-down",
   icon: [384, 512, [8595], "f063", "M169.4 502.6c12.5 12.5 32.8 12.5 45.3 0l160-160c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 402.7 224 32c0-17.7-14.3-32-32-32s-32 14.3-32 32l0 370.7-105.4-105.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l160 160z"]
 };
+var faCircleInfo = {
+  prefix: "fas",
+  iconName: "circle-info",
+  icon: [512, 512, ["info-circle"], "f05a", "M256 512a256 256 0 1 0 0-512 256 256 0 1 0 0 512zM224 160a32 32 0 1 1 64 0 32 32 0 1 1 -64 0zm-8 64l48 0c13.3 0 24 10.7 24 24l0 88 8 0c13.3 0 24 10.7 24 24s-10.7 24-24 24l-80 0c-13.3 0-24-10.7-24-24s10.7-24 24-24l24 0 0-64-24 0c-13.3 0-24-10.7-24-24s10.7-24 24-24z"]
+};
+function createDefaultRecordApi(apiUrl, repo, getToken) {
+  const opts = () => ({ token: getToken() });
+  return {
+    async describe(workspace, record) {
+      return e3ApiClient.workspaceRecordDescribe(apiUrl, repo, workspace, record, opts());
+    },
+    async mutate(workspace, record, mutation, req) {
+      return e3ApiClient.workspaceRecordMutate(apiUrl, repo, workspace, record, mutation, {
+        args: req.args,
+        actor: east.none,
+        limits: east.none
+      }, opts());
+    },
+    async history(workspace, record, limit2, from2) {
+      return e3ApiClient.workspaceRecordHistory(apiUrl, repo, workspace, record, limit2, opts(), from2);
+    }
+  };
+}
+const eastTypeEqual = east.equalFor(internal$1.EastTypeType);
+const RESERVED_MUTATE_FIELDS = /* @__PURE__ */ new Set(["pending", "status", "error", "cancel"]);
+function signatureOfRecordHandleType(handleType) {
+  var _a2, _b2;
+  if (handleType.type !== "Struct") {
+    throw new Error(`Record.bind: handle type must be a Struct; got ${handleType.type}`);
+  }
+  const fields = handleType.value;
+  const read = (_a2 = fields.find((f2) => f2.name === "read")) == null ? void 0 : _a2.type;
+  const mutate = (_b2 = fields.find((f2) => f2.name === "mutate")) == null ? void 0 : _b2.type;
+  if ((read == null ? void 0 : read.type) !== "Function") {
+    throw new Error("Record.bind: handle type is missing its read closure");
+  }
+  if ((mutate == null ? void 0 : mutate.type) !== "Struct") {
+    throw new Error("Record.bind: handle type is missing its mutate struct");
+  }
+  const stateType = read.value.output;
+  const mutations = /* @__PURE__ */ new Map();
+  for (const field of mutate.value) {
+    if (RESERVED_MUTATE_FIELDS.has(field.name)) continue;
+    if (field.type.type !== "Function") {
+      throw new Error(`Record.bind: mutate field "${field.name}" must be a closure`);
+    }
+    mutations.set(field.name, field.type.value.inputs);
+  }
+  return { stateType, mutations };
+}
+function errorOfMutationResult(result) {
+  const outcome = result.outcome;
+  switch (outcome.type) {
+    case "invalid":
+      return { kind: east.variant("invalid", { message: outcome.value.message }), message: outcome.value.message, stderr: "" };
+    case "failed":
+      return {
+        kind: east.variant("failed", { exitCode: outcome.value.exitCode }),
+        message: `reducer exited with code ${outcome.value.exitCode}`,
+        stderr: outcome.value.stderr
+      };
+    case "too_large":
+      return {
+        kind: east.variant("too_large", { bytes: outcome.value.bytes, limit: outcome.value.limit }),
+        message: `new state too large (${outcome.value.bytes} bytes, limit ${outcome.value.limit})`,
+        stderr: outcome.value.stderr
+      };
+    case "timed_out":
+      return {
+        kind: east.variant("timed_out", { ms: outcome.value.ms }),
+        message: `mutation timed out after ${outcome.value.ms}ms (server deadline)`,
+        stderr: outcome.value.stderr
+      };
+    case "conflict":
+      return {
+        kind: east.variant("conflict", { attempts: outcome.value.attempts }),
+        message: `compare-and-swap conflicted after ${outcome.value.attempts} attempts; try again`,
+        stderr: ""
+      };
+    default:
+      return transportError(`unexpected outcome "${outcome.type}"`);
+  }
+}
+function transportError(message) {
+  return { kind: east.variant("transport", { message }), message, stderr: "" };
+}
+function recordPath(name) {
+  return [east.variant("field", "records"), east.variant("field", name)];
+}
+function recordChannelKey(workspace, name) {
+  return `record:${workspace}:${name}`;
+}
+class RecordRuntime extends TrackedChannelStore {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "api", null);
+    __publicField(this, "cache", null);
+    __publicField(this, "workspace", null);
+    // Describe signatures, fetched once per (workspace, record), failures evicted.
+    __publicField(this, "signatureCache", /* @__PURE__ */ new Map());
+    // History per channel, fetched once + refreshed on commit.
+    __publicField(this, "histories", /* @__PURE__ */ new Map());
+    __publicField(this, "historyInFlight", /* @__PURE__ */ new Set());
+    // Channels whose last history fetch failed. Guards `history()` from
+    // re-issuing the request on every render (a failing endpoint would
+    // otherwise spin); cleared on the next commit / on clear() so a later
+    // mutation retries.
+    __publicField(this, "historyFailed", /* @__PURE__ */ new Set());
+  }
+  createEntry() {
+    return { status: "idle", launchSeq: 0 };
+  }
+  // ----- wiring ----------------------------------------------------------
+  /** Install the API adapter + dataset cache + workspace — called by the
+   *  React provider (or a test/showcase harness) before any handle is used. */
+  initialize(api3, cache3, workspace) {
+    this.api = api3;
+    this.cache = cache3;
+    this.workspace = workspace;
+  }
+  /** Tear down the adapter and all record state. */
+  clear() {
+    this.api = null;
+    this.cache = null;
+    this.workspace = null;
+    this.clearChannels();
+    this.signatureCache.clear();
+    this.histories.clear();
+    this.historyInFlight.clear();
+    this.historyFailed.clear();
+  }
+  resolveWorkspace() {
+    if (!this.workspace) {
+      throw new Error("Record.bind: no workspace configured — mount a provider (or call initializeRecordApi) first");
+    }
+    return this.workspace;
+  }
+  /** The deployed describe signature for a record (fetched once, evicted on failure). */
+  signature(workspace, record) {
+    const sigKey = `${workspace}:${record}`;
+    let promise4 = this.signatureCache.get(sigKey);
+    if (!promise4) {
+      const api3 = this.api;
+      if (!api3) return Promise.reject(new Error("Record.bind: no RecordApi installed"));
+      promise4 = api3.describe(workspace, record).catch((err) => {
+        this.signatureCache.delete(sigKey);
+        throw err;
+      });
+      this.signatureCache.set(sigKey, promise4);
+    }
+    return promise4;
+  }
+  /** Validate a mutation's declared arg types against the deployed signature. */
+  async validate(workspace, record, mutation, argTypes) {
+    let sig;
+    try {
+      sig = await this.signature(workspace, record);
+    } catch (err) {
+      return transportError(`failed to describe record "${record}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const deployed = sig.mutations.find((m2) => m2.name === mutation);
+    if (!deployed) {
+      const message = `no mutation "${mutation}" on record "${record}" in the deployed package`;
+      return { kind: east.variant("invalid", { message }), message, stderr: "" };
+    }
+    const argsMatch = deployed.argTypes.length === argTypes.length && deployed.argTypes.every((t4, i) => eastTypeEqual(t4, argTypes[i]));
+    if (!argsMatch) {
+      const message = `signature mismatch for mutation "${mutation}": bound (${argTypes.length} args) disagrees with the deployed package`;
+      return { kind: east.variant("invalid", { message }), message, stderr: "" };
+    }
+    return null;
+  }
+  /** Fetch a record's history once per channel (deduped); notify on settle. */
+  fetchHistory(workspace, record, key) {
+    if (this.historyInFlight.has(key)) return;
+    this.historyInFlight.add(key);
+    void (async () => {
+      const api3 = this.api;
+      try {
+        if (!api3) throw new Error("no RecordApi installed");
+        const result = await api3.history(workspace, record, void 0);
+        this.histories.set(key, result.commits);
+        this.historyFailed.delete(key);
+      } catch {
+        this.historyFailed.add(key);
+      } finally {
+        this.historyInFlight.delete(key);
+        this.notify(key);
+      }
+    })();
+  }
+  // ----- closure semantics -------------------------------------------------
+  launchMutation(workspace, record, mutation, argTypes, args) {
+    const key = recordChannelKey(workspace, record);
+    const { entry, settle } = this.beginLaunch(key, (e3) => {
+      delete e3.error;
+    });
+    const run = (async () => {
+      var _a2;
+      const invalid = await this.validate(workspace, record, mutation, argTypes);
+      if (invalid) {
+        settle((e3) => {
+          e3.status = "failed";
+          e3.error = invalid;
+        });
+        return;
+      }
+      const api3 = this.api;
+      if (!api3) {
+        settle((e3) => {
+          e3.status = "failed";
+          e3.error = transportError("no RecordApi installed");
+        });
+        return;
+      }
+      let result;
+      try {
+        const encoded = args.map((arg, i) => east.encodeBeast2For(argTypes[i])(arg));
+        result = await api3.mutate(workspace, record, mutation, { args: encoded });
+      } catch (err) {
+        settle((e3) => {
+          e3.status = "failed";
+          e3.error = transportError(err instanceof Error ? err.message : String(err));
+        });
+        return;
+      }
+      if (result.outcome.type === "committed") {
+        settle((e3) => {
+          e3.status = "committed";
+          delete e3.error;
+        });
+        void ((_a2 = this.cache) == null ? void 0 : _a2.refresh(workspace));
+        this.histories.delete(key);
+        this.historyFailed.delete(key);
+        this.notify(key);
+      } else {
+        settle((e3) => {
+          e3.status = "failed";
+          e3.error = errorOfMutationResult(result);
+        });
+      }
+    })();
+    entry.inflight = run;
+    void run.finally(() => {
+      const current = this.entries.get(key);
+      if (current && current.inflight === run) delete current.inflight;
+    });
+  }
+  /** Build the handle value for one `Record.bind` platform evaluation. */
+  buildHandle(handleType, name) {
+    const sig = signatureOfRecordHandleType(handleType);
+    const decodeState = east.decodeBeast2For(sig.stateType);
+    const runtime = this;
+    const path2 = recordPath(name);
+    const requireCache = () => {
+      if (!runtime.cache) {
+        throw new Error("Record.bind: no dataset cache configured — mount a provider first");
+      }
+      return runtime.cache;
+    };
+    const mutate = {
+      pending: () => {
+        const ws = runtime.resolveWorkspace();
+        const key = recordChannelKey(ws, name);
+        runtime.track(key);
+        return runtime.entry(key).status === "running";
+      },
+      status: () => {
+        const ws = runtime.resolveWorkspace();
+        const key = recordChannelKey(ws, name);
+        runtime.track(key);
+        return east.variant(runtime.entry(key).status, null);
+      },
+      error: () => {
+        const ws = runtime.resolveWorkspace();
+        const key = recordChannelKey(ws, name);
+        runtime.track(key);
+        const entry = runtime.entry(key);
+        return entry.status === "failed" && entry.error !== void 0 ? east.some(entry.error) : east.none;
+      },
+      cancel: () => {
+        const ws = runtime.resolveWorkspace();
+        runtime.cancelChannel(recordChannelKey(ws, name), (e3) => {
+          delete e3.error;
+          delete e3.inflight;
+        });
+        return null;
+      }
+    };
+    for (const [mutationName, argTypes] of sig.mutations) {
+      mutate[mutationName] = (...args) => {
+        runtime.launchMutation(runtime.resolveWorkspace(), name, mutationName, argTypes, args);
+        return null;
+      };
+    }
+    return {
+      read: () => {
+        const ws = runtime.resolveWorkspace();
+        trackDatasetPath(ws, path2);
+        const bytes = requireCache().read(ws, path2);
+        if (bytes === void 0) {
+          throw new Error(`Record.bind: record state not loaded: ${datasetCacheKey(ws, path2)} (it should be preloaded via the UI task manifest)`);
+        }
+        return decodeState(bytes);
+      },
+      status: () => {
+        const ws = runtime.resolveWorkspace();
+        trackDatasetPath(ws, path2);
+        return requireCache().getStatus(ws, path2);
+      },
+      history: () => {
+        const ws = runtime.resolveWorkspace();
+        const key = recordChannelKey(ws, name);
+        runtime.track(key);
+        const cached = runtime.histories.get(key);
+        if (cached === void 0) {
+          if (!runtime.historyFailed.has(key)) runtime.fetchHistory(ws, name, key);
+          return east.none;
+        }
+        return east.some(cached);
+      },
+      mutate,
+      start: () => {
+        const ws = runtime.resolveWorkspace();
+        const cache3 = requireCache();
+        const inflight = runtime.entry(recordChannelKey(ws, name)).inflight;
+        void Promise.resolve(inflight).catch(() => void 0).then(() => cache3.launchDataflow(ws)).catch(() => void 0);
+        return null;
+      },
+      binding: { name, mutations: [...sig.mutations.keys()] }
+    };
+  }
+  // ----- platform building -------------------------------------------------
+  /** Build a `Record.bind` PlatformFunction bound to this runtime. Pass
+   *  `allowed=null` for an unscoped impl; pass a Set of record names for
+   *  manifest scoping. */
+  buildPlatform(allowed) {
+    return internal.recordBindPlatformFn.implement(
+      (handleType) => (nameArg) => {
+        const name = nameArg;
+        if (allowed && !allowed.has(name)) {
+          throw new Error(
+            `Record.bind: record "${name}" is not in this UI task's manifest — bind it in the task body so derivation records it`
+          );
+        }
+        return this.buildHandle(handleType, name);
+      }
+    );
+  }
+}
+const defaultRecordRuntime = new RecordRuntime();
+function initializeRecordApi(api3, cache3, workspace) {
+  defaultRecordRuntime.initialize(api3, cache3, workspace);
+}
+function clearRecordApi() {
+  defaultRecordRuntime.clear();
+}
+const RecordPlatform = [defaultRecordRuntime.buildPlatform(null)];
+function createScopedRecordPlatform(records) {
+  return [defaultRecordRuntime.buildPlatform(new Set(records))];
+}
+function createInMemoryRecordApi(cache3, workspace, defs2) {
+  const compiled = /* @__PURE__ */ new Map();
+  for (const def of defs2) {
+    const stateType = east.toEastTypeValue(def.stateType);
+    const mutations = /* @__PURE__ */ new Map();
+    for (const m2 of def.mutations) {
+      mutations.set(m2.name, { argTypes: m2.argTypes.map((t4) => east.toEastTypeValue(t4)), reduce: m2.reduce });
+    }
+    const genesis = {
+      hash: `${def.name}-0`.padEnd(64, "0"),
+      parent: east.none,
+      state: `${def.name}-state-0`.padEnd(64, "0"),
+      mutation: "$init",
+      actor: "memory",
+      at: /* @__PURE__ */ new Date(0)
+    };
+    compiled.set(def.name, { stateType, mutations, commits: [genesis], seq: 0 });
+    void cache3.write(workspace, recordPath(def.name), east.encodeBeast2For(stateType)(def.initial));
+  }
+  return {
+    async describe(_ws, record) {
+      const c2 = compiled.get(record);
+      if (!c2) throw new Error(`no in-memory record "${record}"`);
+      return {
+        name: record,
+        mutations: [...c2.mutations].map(([name, m2]) => ({ name, argTypes: m2.argTypes }))
+      };
+    },
+    async mutate(ws, record, mutation, req) {
+      const c2 = compiled.get(record);
+      if (!c2) throw new Error(`no in-memory record "${record}"`);
+      const m2 = c2.mutations.get(mutation);
+      if (!m2) return { outcome: east.variant("invalid", { message: `no mutation "${mutation}"` }) };
+      const current = cache3.read(ws, recordPath(record));
+      const state = current !== void 0 ? east.decodeBeast2For(c2.stateType)(current) : void 0;
+      const args = req.args.map((bytes, i) => east.decodeBeast2For(m2.argTypes[i])(bytes));
+      const next2 = m2.reduce(state, ...args);
+      await cache3.write(ws, recordPath(record), east.encodeBeast2For(c2.stateType)(next2));
+      c2.seq += 1;
+      const hash2 = `${record}-${c2.seq}`.padEnd(64, "0");
+      c2.commits.unshift({
+        hash: hash2,
+        parent: east.some(c2.commits[0].hash),
+        state: `${record}-state-${c2.seq}`.padEnd(64, "0"),
+        mutation,
+        actor: "memory",
+        at: /* @__PURE__ */ new Date(0)
+      });
+      return { outcome: east.variant("committed", { commitHash: hash2, stateHash: `${record}-state-${c2.seq}`.padEnd(64, "0") }) };
+    },
+    async history(_ws, record, limit2) {
+      const c2 = compiled.get(record);
+      if (!c2) throw new Error(`no in-memory record "${record}"`);
+      const commits = limit2 !== void 0 ? c2.commits.slice(0, limit2) : c2.commits;
+      return { commits };
+    }
+  };
+}
+platform.registerReactiveTracker({
+  id: "record-bind",
+  enableTracking: () => defaultRecordRuntime.enableTracking(),
+  disableTracking: () => defaultRecordRuntime.disableTracking(),
+  getStore: () => ({
+    subscribe: (key, cb) => defaultRecordRuntime.subscribe(key, cb),
+    getKeyVersion: (key) => defaultRecordRuntime.getKeyVersion(key)
+  })
+});
+platform.registerPlatformImplementation(RecordPlatform);
 const E3ConfigContext = React.createContext(null);
 function E3Provider({ children: children2, config: config2, queryClient: externalClient }) {
   const client = React.useMemo(
@@ -7514,11 +8034,21 @@ function ReactiveDatasetProvider({
       );
     }
   }, [e3.apiUrl, e3.repo, e3.workspace]);
+  React.useMemo(() => {
+    if (e3.workspace !== void 0) {
+      initializeRecordApi(
+        createDefaultRecordApi(e3.apiUrl, e3.repo ?? "default", () => tokenRef.current),
+        cache3,
+        e3.workspace
+      );
+    }
+  }, [e3.apiUrl, e3.repo, e3.workspace, cache3]);
   React.useEffect(() => {
     return () => {
       const ws = cache3.getConfig().workspace;
       clearReactiveDatasetCache();
       clearFunctionApi();
+      clearRecordApi();
       cache3.destroy();
       if (ws) clearBindingRegistry(ws);
       else clearBindingRegistry();
@@ -21879,13 +22409,13 @@ var hashIterableInts = function hashIterableInts2(iterator) {
   }
   return hash2;
 };
-var hashInt = function hashInt2(num) {
+var hashInt = function hashInt2(num2) {
   var seed = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_HASH_SEED;
-  return seed * K + num | 0;
+  return seed * K + num2 | 0;
 };
-var hashIntAlt = function hashIntAlt2(num) {
+var hashIntAlt = function hashIntAlt2(num2) {
   var seed = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_HASH_SEED_ALT;
-  return (seed << 5) + seed + num | 0;
+  return (seed << 5) + seed + num2 | 0;
 };
 var combineHashes = function combineHashes2(hash1, hash2) {
   return hash1 * 2097152 + hash2;
@@ -23472,7 +24002,7 @@ var max = function max2(arr2) {
   }
   return max5;
 };
-var mean$1 = function mean(arr2) {
+var mean = function mean2(arr2) {
   var begin3 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
   var end3 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : arr2.length;
   var total = 0;
@@ -25785,7 +26315,7 @@ var getPreference = function getPreference2(S2, preference) {
   if (preference === "median") {
     p2 = median(S2);
   } else if (preference === "mean") {
-    p2 = mean$1(S2);
+    p2 = mean(S2);
   } else if (preference === "min") {
     p2 = min(S2);
   } else if (preference === "max") {
@@ -56758,7 +57288,7 @@ function useBindingValue(binding) {
   return { value, mode, pending, mutate, commit, discard };
 }
 const IDLE = { call: () => {
-}, result: null, status: "idle", pending: false };
+}, result: null, status: "idle", pending: false, error: null };
 function useFuncCall(name, inputs, output2) {
   const workspace = getReactiveDatasetCache().getConfig().workspace ?? "";
   const ready4 = !!name && !!inputs && workspace !== "";
@@ -56781,15 +57311,22 @@ function useFuncCall(name, inputs, output2) {
     React.useCallback(() => channelKey ? defaultFuncRuntime.getKeyVersion(channelKey) : 0, [channelKey])
   );
   return React.useMemo(() => {
+    var _a2;
     if (!handle) return IDLE;
     let result = null;
     let status = "idle";
     let pending = false;
+    let error3 = null;
     try {
       const read = handle.read();
       result = read.type === "some" ? read.value : null;
       status = handle.status().type;
       pending = handle.pending();
+      const err = handle.error();
+      if (err.type === "some") {
+        const v3 = err.value;
+        error3 = { kind: ((_a2 = v3.kind) == null ? void 0 : _a2.type) ?? "failed", message: v3.message ?? "", stdout: v3.stdout ?? "", stderr: v3.stderr ?? "" };
+      }
     } catch {
     }
     return { call: (...args) => {
@@ -56797,7 +57334,7 @@ function useFuncCall(name, inputs, output2) {
         handle.call(...args);
       } catch {
       }
-    }, result, status, pending };
+    }, result, status, pending, error: error3 };
   }, [handle, version2]);
 }
 var propTypes = { exports: {} };
@@ -59041,6 +59578,370 @@ function Circle(_ref2) {
     className: cx("visx-circle", className)
   }, restProps));
 }
+function fillHelp(entry, vars) {
+  const sub = (s2) => s2.replace(/\{(\w+)\}/g, (m2, k2) => k2 in vars ? vars[k2] : m2);
+  return {
+    term: sub(entry.term),
+    gist: sub(entry.gist),
+    detail: sub(entry.detail),
+    ...entry.jargon !== void 0 ? { jargon: sub(entry.jargon) } : {}
+  };
+}
+const HELP = {
+  // ── Guidance mode (the toggle itself) ───────────────────────────────
+  guidance: {
+    term: "Guidance",
+    gist: "Plain-language explainers for everything on this surface.",
+    detail: "While this is on, hover any heading, value or chart label to see what it means — in business terms, with the statistical name underneath. Click to turn it off."
+  },
+  // ── Header ──────────────────────────────────────────────────────────
+  header: {
+    term: "The question",
+    gist: "You’re asking whether {treatment} actually moved {outcome}.",
+    detail: "Pick the lever you changed and the result you cared about, then hit Run — the surface answers whether the change is real and trustworthy.",
+    jargon: "a binary-treatment causal effect"
+  },
+  // ── Set-up rail ─────────────────────────────────────────────────────
+  step_treatment: {
+    term: "What did you change?",
+    gist: "The lever you’re testing — a yes/no flag on each {subject}.",
+    detail: "It splits {subjects} into a “did” group and a “didn’t” group; the whole experiment compares those two.",
+    jargon: "the treatment (binary)"
+  },
+  step_outcome: {
+    term: "What did you want it to improve?",
+    gist: "The result you’re hoping {treatment} moved.",
+    detail: "A number measured on each {subject} (revenue, a duration, a score, …). The effect is the change in this we can credit to the lever.",
+    jargon: "the outcome"
+  },
+  step_confounders: {
+    term: "What else was different?",
+    gist: "Things about the “did” group that could also explain the change.",
+    detail: "If the {subjects} you treated already differed on something that matters — bigger, older, higher-value — that, not the lever, could be moving the result. We level the playing field on each of these so the comparison is fair. Add the ones you suspect.",
+    jargon: "confounders / the backdoor adjustment set"
+  },
+  step_population: {
+    term: "Which {subjects}?",
+    gist: "Narrow the experiment to a slice of the {subjects}.",
+    detail: "Filter to a subset you care about — a region, a period, a category — before measuring, so the answer is about the {subjects} that matter.",
+    jargon: "population / cohort filter"
+  },
+  adv_method: {
+    term: "How to compare",
+    gist: "The maths used to make the like-for-like comparison.",
+    detail: "“Regression” fits a line through the confounders; “re-weighting” up-weights rare look-alikes. They usually agree — if they don’t, treat the result with care.",
+    jargon: "estimator: linear regression vs propensity-score weighting"
+  },
+  adv_estimand: {
+    term: "Answer for",
+    gist: "Who the effect is reported for.",
+    detail: "“All” averages over everyone; “only treated” asks what the lever did for the {subjects} you actually treated — useful when you’d only ever apply it to them.",
+    jargon: "estimand: ATE vs ATT"
+  },
+  confounder_imbalance: {
+    term: "How lopsided this one was",
+    gist: "How different the two groups were on this factor, before adjusting.",
+    detail: "A long bar means the treated and untreated {subjects} started far apart here — exactly the kind of gap the adjustment has to close.",
+    jargon: "standardised mean difference (SMD)"
+  },
+  // ── Tabs ────────────────────────────────────────────────────────────
+  tab_answer: {
+    term: "Answer",
+    gist: "The headline: did {treatment} move {outcome}, and by how much?",
+    detail: "Shows the raw gap, the fair like-for-like estimate, and an honest verdict."
+  },
+  tab_trust: {
+    term: "Can we trust it?",
+    gist: "The stress tests we ran to try to break the answer.",
+    detail: "Each check probes a way the result could be a fluke; green means it held up."
+  },
+  tab_dose: {
+    term: "How much?",
+    gist: "How the result changes as a factor goes up or down.",
+    detail: "Not just yes/no — the shape of the response, so you can find the sweet spot."
+  },
+  // ── Answer tab ──────────────────────────────────────────────────────
+  answer_effect: {
+    term: "Like-for-like effect",
+    gist: "The change in {outcome} we can credit to {treatment}.",
+    detail: "It compares treated vs untreated {subjects} who were otherwise similar — so it strips out “who you targeted” and leaves the lever’s real impact.",
+    jargon: "the backdoor-adjusted average treatment effect"
+  },
+  answer_ci: {
+    term: "95% range",
+    gist: "Where the true effect most likely sits.",
+    detail: "If this range doesn’t cross 0, the effect is real, not noise. The wider it is, the less certain — usually because of fewer {subjects}.",
+    jargon: "95% confidence interval"
+  },
+  answer_flip: {
+    term: "Raw and like-for-like disagree",
+    gist: "The plain average points one way; the fair comparison points the other.",
+    detail: "This happens when the treated group differed sharply on a confounder. Trust the like-for-like number — the raw gap is misleading here.",
+    jargon: "confounding / Simpson’s-paradox sign flip"
+  },
+  answer_cautious: {
+    term: "Treat this as provisional",
+    gist: "We got a number, but a trust check failed.",
+    detail: "The estimate may still be driven by something we didn’t adjust for. See “Can we trust it?” before acting on it.",
+    jargon: "adjustment_insufficient verdict"
+  },
+  forest_plot: {
+    term: "Raw average vs. like-for-like",
+    gist: "The misleading number next to the fair one.",
+    detail: "Each bar is an estimate with its uncertainty range; the dashed line is “no effect”. A bar clear of that line is a real change.",
+    jargon: "a forest plot of naive vs adjusted estimates"
+  },
+  forest_naive: {
+    term: "Raw average",
+    gist: "The plain difference, with no adjusting.",
+    detail: "Just treated-minus-untreated. It mixes in who you targeted, so it can mislead — it’s here only as the “before” picture.",
+    jargon: "the unadjusted mean difference"
+  },
+  forest_adjusted: {
+    term: "Like-for-like",
+    gist: "The fair comparison after levelling the confounders.",
+    detail: "This is the number to act on — what {treatment} did among otherwise-similar {subjects}.",
+    jargon: "the adjusted effect"
+  },
+  balance: {
+    term: "How unbalanced each one was",
+    gist: "How far apart the two groups started on each factor.",
+    detail: "Big bars are the factors the adjustment had to work hardest to correct — and the ones most worth double-checking.",
+    jargon: "pre-adjustment covariate balance (SMD)"
+  },
+  counts: {
+    term: "The {subject} counts",
+    gist: "How many {subjects} went into the comparison.",
+    detail: "“Compared like-for-like” are the ones with a fair match on the other side; “no fair match” were set aside because nobody comparable existed.",
+    jargon: "n total / on-support / off-support"
+  },
+  // ── Refusal zones + overlap ─────────────────────────────────────────
+  overlap_histogram: {
+    term: "Do the two groups overlap?",
+    gist: "Whether treated and untreated {subjects} actually look alike anywhere.",
+    detail: "Each bar is how many {subjects} sit at a given “likelihood of being treated”. Where the two arms both have bars, a fair comparison exists; if they barely meet, there’s nothing to compare.",
+    jargon: "propensity-score overlap / common support"
+  },
+  refusal_positivity: {
+    term: "No like-for-like comparison exists",
+    gist: "The treated and untreated {subjects} are too different to compare.",
+    detail: "For almost every treated {subject} there’s no similar untreated one (or vice-versa), so there’s no fair “other side”. We refuse rather than extrapolate into thin air. Try fewer or different confounders.",
+    jargon: "positivity / overlap violation"
+  },
+  refusal_not_estimable: {
+    term: "Can’t be estimated",
+    gist: "Almost every {subject} is on one side of {treatment}, so there’s no comparison group.",
+    detail: "Measuring an effect needs a decent number of {subjects} who got the lever AND who didn’t. When one side is just a handful, we refuse to guess rather than read too much into a few people.",
+    jargon: "no treatment variation"
+  },
+  // ── Trust tab ───────────────────────────────────────────────────────
+  trust_intro: {
+    term: "Can we trust it?",
+    gist: "Before believing the answer, we tried to break it.",
+    detail: "Each row is a different way the result could be a fluke; colour shows whether it held up (pass) or wobbled (caution)."
+  },
+  check_shuffle: {
+    term: "Shuffle test",
+    gist: "We randomly re-label who got {treatment} and re-measure.",
+    detail: "On fake labels a genuine effect should collapse to nothing. If a “fake” effect still appears, the real one isn’t trustworthy.",
+    jargon: "placebo / permutation refuter"
+  },
+  check_dropsome: {
+    term: "Drop-some test",
+    gist: "We re-run on random slices of the {subjects}.",
+    detail: "A trustworthy effect barely moves when you drop some data; a jumpy one is resting on a few {subjects}.",
+    jargon: "data-subset refuter"
+  },
+  check_decoy: {
+    term: "Decoy factor",
+    gist: "We add a totally random extra factor and re-measure.",
+    detail: "A made-up factor shouldn’t change the answer. If it does, the model is over-reacting to noise.",
+    jargon: "random-common-cause refuter"
+  },
+  check_hidden: {
+    term: "Hidden cause",
+    gist: "How strong an unrecorded cause would have to be to overturn the result.",
+    detail: "Something you didn’t measure could drive both who got {treatment} and {outcome}. “Holds throughout” means only an implausibly strong hidden cause could flip it.",
+    jargon: "unobserved-confounding sensitivity / E-value"
+  },
+  sensitivity: {
+    term: "Effect as a hidden cause gets stronger",
+    gist: "What happens to the effect if an unrecorded cause is dialled up.",
+    detail: "The line is the estimate as a simulated hidden cause grows. The point where it crosses 0 is how much hidden bias it would take to erase the result.",
+    jargon: "sensitivity (tipping-point) curve"
+  },
+  // ── Dose tab ────────────────────────────────────────────────────────
+  dose_curve: {
+    term: "{outcome} gained vs. {feature}",
+    gist: "How {outcome} responds as {feature} goes up.",
+    detail: "The line is the average change in {outcome} at each level of {feature}, with its uncertainty band — the shape tells you where more pays off and where it flattens.",
+    jargon: "accumulated local effects (ALE) dose-response"
+  },
+  dose_here: {
+    term: "You are here",
+    gist: "Where most of your {subjects} currently sit on {feature}.",
+    detail: "The busiest level today — your starting point for deciding whether to push higher or lower.",
+    jargon: "the modal bin"
+  },
+  dose_sweet: {
+    term: "Sweet spot",
+    gist: "Where the gains are solid and start to flatten.",
+    detail: "Past here, pushing {feature} higher buys little extra {outcome} — a sensible target.",
+    jargon: "the diminishing-returns knee"
+  },
+  dose_reco: {
+    term: "Recommended",
+    gist: "The level of {feature} we’d aim for.",
+    detail: "The sweet-spot level and the {outcome} you’d expect there, with its range — and the trade-off of going one step further.",
+    jargon: "the recommended operating point"
+  },
+  dose_marginal: {
+    term: "Extra {outcome} per step",
+    gist: "What each additional step of {feature} buys you.",
+    detail: "Tall early bars then short ones is the classic diminishing-returns shape — spend effort where the bars are tall.",
+    jargon: "marginal / incremental effect per bin"
+  },
+  // ── Verdicts ────────────────────────────────────────────────────────
+  verdict_causal: {
+    term: "Causal",
+    gist: "A real change you can credit to {treatment} — and it held up.",
+    detail: "The like-for-like effect is clear, sizeable, and survived the trust checks. Safe to act on.",
+    jargon: "a robust, identified effect"
+  },
+  verdict_modest: {
+    term: "Modest / unclear",
+    gist: "There may be an effect, but it’s small or fuzzy.",
+    detail: "The fair comparison can’t cleanly separate it from no-effect (the range straddles 0, or it’s tiny). Don’t bet much on it.",
+    jargon: "effect CI spans zero / below materiality"
+  },
+  verdict_adjustment_insufficient: {
+    term: "Not trustworthy yet",
+    gist: "We got a number, but a trust check failed.",
+    detail: "Likely something we didn’t adjust for is still in play. Treat as provisional and look at “Can we trust it?”.",
+    jargon: "placebo / robustness failure"
+  },
+  verdict_non_identifiable_positivity: {
+    term: "No fair comparison",
+    gist: "Treated and untreated {subjects} don’t overlap enough to compare.",
+    detail: "There’s no like-for-like “other side”, so any number would be extrapolation. See the overlap chart.",
+    jargon: "positivity / overlap violation"
+  },
+  verdict_not_estimable: {
+    term: "Can’t be estimated",
+    gist: "Almost everyone is on one side of {treatment} — no comparison group.",
+    detail: "One arm is just a handful of {subjects}, so we won’t guess an effect from it.",
+    jargon: "no treatment variation"
+  },
+  // ── Validate tab ────────────────────────────────────────────────────
+  tab_validate: {
+    term: "Validate",
+    gist: "The real experiment you’d run to prove this — for sure.",
+    detail: "This analysis adjusted for what it could measure. A controlled trial — assigning {treatment} at random — removes any leftover doubt. This tab sizes that trial."
+  },
+  validate_size: {
+    term: "How many to run",
+    gist: "The number of {subjects} the trial needs.",
+    detail: "Enough to spot a change this size if it’s real. A bigger or cleaner effect needs fewer; a small or noisy one needs many more.",
+    jargon: "required sample size at the target power"
+  },
+  validate_split: {
+    term: "How to split them",
+    gist: "How many get {treatment} versus are left alone.",
+    detail: "Assign at random — that’s what makes the two groups comparable with no adjusting. An even split is the most efficient; treating fewer needs a larger total.",
+    jargon: "randomised allocation between arms"
+  },
+  validate_match: {
+    term: "Match the groups on",
+    gist: "Keep both groups balanced on these — they were lopsided last time.",
+    detail: "Give each group the same mix of these factors when you split, so neither one starts ahead. These are the factors that muddied the original comparison most.",
+    jargon: "stratified / blocked randomisation on the high-imbalance covariates"
+  },
+  validate_power: {
+    term: "Chance of detecting it",
+    gist: "How likely the trial is to catch the effect, by size.",
+    detail: "More {subjects} means a better chance of a clear result. The marker shows where today’s data sits — usually well short of a confident answer.",
+    jargon: "statistical power vs sample size"
+  },
+  validate_holdback: {
+    term: "Hold back a control",
+    gist: "Keep a random group untreated to compare against.",
+    detail: "Right now almost everything got {treatment}, so there’s nothing to compare to. Next time, leave a random sample untreated — that group becomes the fair baseline.",
+    jargon: "a randomised control arm"
+  },
+  // ── Journal ─────────────────────────────────────────────────────────
+  journal: {
+    term: "Committed experiments",
+    gist: "A log of the questions you’ve saved.",
+    detail: "Each row is a framing you committed — its verdict and headline effect — so the team can see what’s been tried and what held up.",
+    jargon: "the experiment journal"
+  }
+};
+const GuidanceContext = React.createContext({ on: true, vars: {} });
+function GuidanceProvider({ on: on3, vars, children: children2 }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(GuidanceContext.Provider, { value: { on: on3, vars }, children: children2 });
+}
+function HelpCard({ id: id3, extraVars }) {
+  const { vars } = React.useContext(GuidanceContext);
+  const e3 = fillHelp(HELP[id3], { ...vars, ...extraVars });
+  const slot = react.useSlotRecipe({ key: "hoverCard" })();
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "1.5", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: slot.title, mb: "0", children: e3.term }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "body.sm", color: "fg.default", lineHeight: "1.5", children: e3.gist }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: slot.description, lineHeight: "1.5", children: e3.detail }),
+    e3.jargon && /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "caption", color: "fg.subtle", mt: "0.5", pt: "1.5", borderTopWidth: "1px", borderColor: "border.subtle", children: [
+      "Technically: ",
+      e3.jargon
+    ] })
+  ] });
+}
+function Hover({ id: id3, extraVars, trigger }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.HoverCard.Root, { openDelay: 150, closeDelay: 80, size: "sm", positioning: { placement: "top" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(react.HoverCard.Trigger, { asChild: true, children: trigger }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Portal, { children: /* @__PURE__ */ jsxRuntime.jsx(react.HoverCard.Positioner, { children: /* @__PURE__ */ jsxRuntime.jsxs(react.HoverCard.Content, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.HoverCard.Arrow, { children: /* @__PURE__ */ jsxRuntime.jsx(react.HoverCard.ArrowTip, {}) }),
+      /* @__PURE__ */ jsxRuntime.jsx(HelpCard, { id: id3, extraVars })
+    ] }) }) })
+  ] });
+}
+function Help({ id: id3, extraVars, children: children2, display = "inline", gap }) {
+  const { on: on3 } = React.useContext(GuidanceContext);
+  if (!on3) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: children2 });
+  return /* @__PURE__ */ jsxRuntime.jsx(Hover, { id: id3, extraVars, trigger: (
+    // `tabIndex={0}` makes the term keyboard-focusable — the HoverCard's zag
+    // machine opens on focus, so the glossary is reachable without a pointer.
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.Box,
+      {
+        as: "span",
+        cursor: "help",
+        tabIndex: 0,
+        display,
+        ...gap ? { alignItems: "center", gap } : {},
+        _focusVisible: { outline: "1px dotted", outlineColor: "brand.fg", outlineOffset: "2px", borderRadius: "2px" },
+        children: children2
+      }
+    )
+  ) });
+}
+function GuidanceToggle({ on: on3, onToggle }) {
+  const iconButton = react.useRecipe({ key: "iconButton" });
+  return /* @__PURE__ */ jsxRuntime.jsx(Hover, { id: "guidance", trigger: /* @__PURE__ */ jsxRuntime.jsx(
+    react.Box,
+    {
+      as: "button",
+      css: iconButton({ variant: on3 ? "subtle" : "ghost", size: "sm" }),
+      onClick: onToggle,
+      "aria-pressed": on3,
+      "aria-label": "Toggle guidance",
+      color: on3 ? "brand.fg" : "fg.muted",
+      children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faCircleInfo })
+    }
+  ) });
+}
+function ChartLabel({ x: x2, y: y2, w: w2, align, size: size3, weight: weight8, color: color2, family, help, children: children2 }) {
+  const span = /* @__PURE__ */ jsxRuntime.jsx("span", { style: { fontSize: `${size3}px`, fontFamily: family, fontWeight: weight8, color: color2, lineHeight: 1, whiteSpace: "nowrap" }, children: children2 });
+  return /* @__PURE__ */ jsxRuntime.jsx("foreignObject", { x: x2, y: y2, width: w2, height: size3 + 6, style: { overflow: "visible" }, children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: { textAlign: align, fontSize: `${size3}px`, lineHeight: 1 }, children: help ? /* @__PURE__ */ jsxRuntime.jsx(Help, { id: help, children: span }) : span }) });
+}
 function svgText(size3, fill, family, weight8) {
   return { fontSize: `${size3}px`, fill, fontFamily: family, ...weight8 !== void 0 ? { fontWeight: weight8 } : {} };
 }
@@ -59096,7 +59997,7 @@ const niceCeil = (v3) => {
   const step3 = n2 <= 1 ? 1 : n2 <= 1.5 ? 1.5 : n2 <= 2 ? 2 : n2 <= 3 ? 3 : n2 <= 4 ? 4 : n2 <= 5 ? 5 : n2 <= 6 ? 6 : n2 <= 8 ? 8 : 10;
   return step3 * mag;
 };
-function ForestPlot({ rows, min: min4, max: max5, unit: unit2, height: height2 }) {
+function ForestPlot({ rows, min: min4, max: max5, unit: unit2, height: height2, rowHelp }) {
   const t4 = useChartTheme();
   const [ref, w2] = useMeasuredWidth();
   const n2 = rows.length;
@@ -59106,11 +60007,14 @@ function ForestPlot({ rows, min: min4, max: max5, unit: unit2, height: height2 }
   const innerH = hPx - padT - padB;
   const x2 = createLinearScale({ domain: [min4, max5], range: [0, innerW] });
   const rowH = innerH / Math.max(1, n2);
-  const zeroX = x2(0);
-  const ticks2 = [min4, 0, max5];
+  const zeroX = Math.max(0, Math.min(innerW, x2(0)));
+  const frac = (v3) => max5 > min4 ? (v3 - min4) / (max5 - min4) : 0.5;
+  const anchorAt = (v3) => frac(v3) < 0.06 ? "start" : frac(v3) > 0.94 ? "end" : "middle";
+  const zf = frac(0);
+  const ticks2 = zf > 0.12 && zf < 0.88 ? [min4, 0, max5] : [min4, max5];
   return /* @__PURE__ */ jsxRuntime.jsx(react.Box, { ref, width: "100%", height: `${hPx}px`, children: w2 > 0 && /* @__PURE__ */ jsxRuntime.jsx("svg", { width: w2, height: hPx, style: { display: "block" }, children: /* @__PURE__ */ jsxRuntime.jsxs(Group, { left: padL, top: padT, children: [
     /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: zeroX, y: -4 }, to: { x: zeroX, y: innerH }, stroke: t4.muted, strokeWidth: 1, strokeDasharray: "3 2" }),
-    /* @__PURE__ */ jsxRuntime.jsx("text", { x: zeroX, y: -6, textAnchor: "middle", style: svgText(t4.labelSize, t4.muted, t4.mono), children: "no effect" }),
+    /* @__PURE__ */ jsxRuntime.jsx("text", { x: zeroX, y: -6, textAnchor: anchorAt(0), style: svgText(t4.labelSize, t4.muted, t4.mono), children: "no effect" }),
     rows.map((r2, i) => {
       const cy = rowH * i + rowH / 2;
       const col = t4.tone(r2.tone);
@@ -59119,20 +60023,20 @@ function ForestPlot({ rows, min: min4, max: max5, unit: unit2, height: height2 }
         /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: x2(r2.lo), y: -4 }, to: { x: x2(r2.lo), y: 4 }, stroke: col, strokeWidth: 1.5 }),
         /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: x2(r2.hi), y: -4 }, to: { x: x2(r2.hi), y: 4 }, stroke: col, strokeWidth: 1.5 }),
         /* @__PURE__ */ jsxRuntime.jsx(Circle, { cx: x2(r2.est), cy: 0, r: t4.scatterRadius, fill: col, stroke: t4.surface, strokeWidth: 1.8 }),
-        /* @__PURE__ */ jsxRuntime.jsx("text", { x: -padL + 2, y: -3, style: svgText(t4.labelSize, t4.ink, t4.body, 600), children: r2.label }),
+        /* @__PURE__ */ jsxRuntime.jsx(ChartLabel, { x: -padL + 2, y: -13, w: padL - 6, align: "left", size: t4.labelSize, weight: 600, color: t4.ink, family: t4.body, ...(rowHelp == null ? void 0 : rowHelp[i]) ? { help: rowHelp[i] } : {}, children: r2.label }),
         r2.note && /* @__PURE__ */ jsxRuntime.jsx("text", { x: -padL + 2, y: 9, style: svgText(9, t4.faint, t4.body), children: r2.note }),
         /* @__PURE__ */ jsxRuntime.jsx("text", { x: innerW + padR - 2, y: 4, textAnchor: "end", style: svgText(t4.titleSize, col, t4.mono, 700), children: signed$1(r2.est) })
       ] }, i);
     }),
     /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: 0, y: innerH }, to: { x: innerW, y: innerH }, stroke: t4.rule, strokeWidth: 1 }),
-    ticks2.map((tk, i) => /* @__PURE__ */ jsxRuntime.jsxs(Group, { left: x2(tk), children: [
+    ticks2.map((tk, i) => /* @__PURE__ */ jsxRuntime.jsxs(Group, { left: Math.max(0, Math.min(innerW, x2(tk))), children: [
       /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: 0, y: innerH }, to: { x: 0, y: innerH + 4 }, stroke: t4.ruleStrong, strokeWidth: 1 }),
-      /* @__PURE__ */ jsxRuntime.jsx("text", { x: 0, y: innerH + 14, textAnchor: i === 0 ? "start" : i === ticks2.length - 1 ? "end" : "middle", style: svgText(t4.labelSize, t4.muted, t4.mono), children: signed$1(tk) })
+      /* @__PURE__ */ jsxRuntime.jsx("text", { x: 0, y: innerH + 14, textAnchor: anchorAt(tk), style: svgText(t4.labelSize, t4.muted, t4.mono), children: signed$1(tk) })
     ] }, `t${i}`)),
     unit2 && /* @__PURE__ */ jsxRuntime.jsx("text", { x: innerW / 2, y: innerH + 26, textAnchor: "middle", style: svgText(t4.labelSize, t4.muted, t4.mono), children: unit2 })
   ] }) }) });
 }
-function AreaRange({ lo: lo2, mid, hi, xTicks = [], yTicks = [], zero: zero2, tone: toneName, marks = [], height: height2 }) {
+function AreaRange({ lo: lo2, mid, hi, xTicks = [], yTicks = [], zero: zero2, tone: toneName, marks = [], height: height2, yFormat = "signed" }) {
   const t4 = useChartTheme();
   const [ref, w2] = useMeasuredWidth();
   const hPx = height2 ?? 100;
@@ -59144,13 +60048,18 @@ function AreaRange({ lo: lo2, mid, hi, xTicks = [], yTicks = [], zero: zero2, to
   const innerW = Math.max(0, w2 - padL - padR);
   const innerH = hPx - padT - padB;
   const xScale = createLinearScale({ domain: [0, Math.max(1, mid.length - 1)], range: [0, innerW] });
-  const dataMin = Math.min(...lo2, zero2 ?? Infinity);
-  const dataMax = Math.max(...hi, zero2 ?? -Infinity);
+  const fin = (x2, fallback) => typeof x2 === "number" && Number.isFinite(x2) ? x2 : fallback;
+  const data4 = mid.map((m2, i) => {
+    const mm = fin(m2, 0);
+    return { i, lo: fin(lo2[i], mm), hi: fin(hi[i], mm), mid: mm };
+  });
+  const dataMin = Math.min(...data4.map((d2) => d2.lo), zero2 ?? Infinity);
+  const dataMax = Math.max(...data4.map((d2) => d2.hi), zero2 ?? -Infinity);
   const yHiN = niceCeil(Math.max(dataMax, 0));
   const yLoN = dataMin < -0.08 * yHiN ? -niceCeil(-dataMin) : 0;
   const yScale = createLinearScale({ domain: [yLoN, yHiN], range: [innerH, 0] });
-  const yLabels = [signed$1(yHiN), signed$1((yHiN + yLoN) / 2), signed$1(yLoN)];
-  const data4 = mid.map((m2, i) => ({ i, lo: lo2[i] ?? m2, hi: hi[i] ?? m2, mid: m2 }));
+  const yfmt = (v3) => yFormat === "percent" ? `${Math.round(v3)}%` : signed$1(v3);
+  const yLabels = [yfmt(yHiN), yfmt((yHiN + yLoN) / 2), yfmt(yLoN)];
   return /* @__PURE__ */ jsxRuntime.jsx(react.Box, { ref, width: "100%", height: `${hPx}px`, children: w2 > 0 && /* @__PURE__ */ jsxRuntime.jsx("svg", { width: w2, height: hPx, style: { display: "block" }, children: /* @__PURE__ */ jsxRuntime.jsxs(Group, { left: padL, top: padT, children: [
     /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: 0, y: 0 }, to: { x: 0, y: innerH }, stroke: t4.rule, strokeWidth: 1 }),
     yTicks.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
@@ -59163,11 +60072,17 @@ function AreaRange({ lo: lo2, mid, hi, xTicks = [], yTicks = [], zero: zero2, to
     /* @__PURE__ */ jsxRuntime.jsx(LinePath, { data: data4, x: (d2) => xScale(d2.i), y: (d2) => yScale(d2.mid), curve: monotoneX, stroke: col, strokeWidth: t4.lineWidth }),
     marks.map((m2, i) => {
       const mc = t4.tone(m2.tone);
-      const dotY = yScale(mid[m2.at] ?? 0);
+      const dotY = yScale(fin(mid[m2.at], 0));
+      const labY = Math.max(9, dotY - 9);
+      const atEnd = m2.at >= mid.length - 2;
+      const atStart = m2.at <= 1;
+      const align = atEnd ? "right" : atStart ? "left" : "center";
+      const labW = m2.label.length * 6 + 6;
+      const labX = atEnd ? -labW : atStart ? 0 : -labW / 2;
       return /* @__PURE__ */ jsxRuntime.jsxs(Group, { left: xScale(m2.at), children: [
         /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: 0, y: -2 }, to: { x: 0, y: innerH }, stroke: mc, strokeWidth: 1, strokeDasharray: "2 3" }),
         /* @__PURE__ */ jsxRuntime.jsx(Circle, { cx: 0, cy: dotY, r: t4.dotRadius, fill: mc, stroke: t4.surface, strokeWidth: 1.5 }),
-        /* @__PURE__ */ jsxRuntime.jsx("text", { x: 0, y: Math.max(9, dotY - 9), textAnchor: m2.at >= mid.length - 2 ? "end" : m2.at <= 1 ? "start" : "middle", style: svgText(t4.labelSize, mc, t4.body, 500), children: m2.label })
+        /* @__PURE__ */ jsxRuntime.jsx(ChartLabel, { x: labX, y: labY - 11, w: labW, align, size: t4.labelSize, weight: 500, color: mc, family: t4.body, ...m2.help ? { help: m2.help } : {}, children: m2.label })
       ] }, `mk${i}`);
     }),
     /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: 0, y: innerH }, to: { x: innerW, y: innerH }, stroke: t4.rule, strokeWidth: 1 }),
@@ -59177,17 +60092,54 @@ function AreaRange({ lo: lo2, mid, hi, xTicks = [], yTicks = [], zero: zero2, to
     })
   ] }) }) });
 }
+function OverlapHistogram({ treated, control, domain = [0, 1], supportLabel, positivityOk, height: height2 }) {
+  const t4 = useChartTheme();
+  const [ref, w2] = useMeasuredWidth();
+  const hPx = height2 ?? 150;
+  const padL = 8, padR = 8, padT = 16, padB = 26;
+  const innerW = Math.max(0, w2 - padL - padR);
+  const innerH = hPx - padT - padB;
+  const centerY = innerH / 2;
+  const halfH = centerY - 4;
+  const bins = Math.max(treated.length, control.length);
+  const x2 = createLinearScale({ domain, range: [0, innerW] });
+  const span = domain[1] - domain[0];
+  const binW = bins > 0 ? innerW / bins : innerW;
+  const barW = Math.max(1, binW * 0.78);
+  const maxVal = Math.max(1e-9, ...treated, ...control);
+  const tCol = t4.tone("pos");
+  const cCol = t4.tone("muted");
+  const ticks2 = [domain[0], (domain[0] + domain[1]) / 2, domain[1]];
+  const cx2 = (i) => x2(domain[0] + (i + 0.5) / bins * span);
+  return /* @__PURE__ */ jsxRuntime.jsx(react.Box, { ref, width: "100%", height: `${hPx}px`, children: w2 > 0 && /* @__PURE__ */ jsxRuntime.jsx("svg", { width: w2, height: hPx, style: { display: "block" }, children: /* @__PURE__ */ jsxRuntime.jsxs(Group, { left: padL, top: padT, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("text", { x: 0, y: -4, style: svgText(9, t4.faint, t4.body), children: "treated ↑" }),
+    supportLabel && /* @__PURE__ */ jsxRuntime.jsx("text", { x: innerW, y: -4, textAnchor: "end", style: svgText(t4.labelSize, positivityOk ? t4.tone("pos") : t4.tone("warn"), t4.mono, 600), children: supportLabel }),
+    Array.from({ length: bins }, (_2, i) => {
+      const ht = Number(treated[i] ?? 0) / maxVal * halfH;
+      const hc = Number(control[i] ?? 0) / maxVal * halfH;
+      const left = cx2(i) - barW / 2;
+      return /* @__PURE__ */ jsxRuntime.jsxs(Group, { children: [
+        ht > 0 && /* @__PURE__ */ jsxRuntime.jsx("rect", { x: left, y: centerY - ht, width: barW, height: ht, fill: tCol, fillOpacity: 0.85, rx: 0.5 }),
+        hc > 0 && /* @__PURE__ */ jsxRuntime.jsx("rect", { x: left, y: centerY, width: barW, height: hc, fill: cCol, fillOpacity: 0.6, rx: 0.5 })
+      ] }, i);
+    }),
+    /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: 0, y: centerY }, to: { x: innerW, y: centerY }, stroke: t4.ruleStrong, strokeWidth: 1 }),
+    /* @__PURE__ */ jsxRuntime.jsx("text", { x: 0, y: innerH + 4, style: svgText(9, t4.faint, t4.body), children: "untreated ↓" }),
+    ticks2.map((tk, i) => /* @__PURE__ */ jsxRuntime.jsx("text", { x: x2(tk), y: innerH + 16, textAnchor: i === 0 ? "start" : i === ticks2.length - 1 ? "end" : "middle", style: svgText(t4.labelSize, t4.muted, t4.mono), children: fmt$2(tk) }, `x${i}`))
+  ] }) }) });
+}
 const arr = (v3) => v3 ? Array.from(v3, Number) : [];
+const arrI = (v3) => v3 ? Array.from(v3, Number) : [];
 const getOpt = (o2) => o2 && o2.type === "some" ? o2.value : void 0;
-const fmt$1 = (x2) => Number.isInteger(x2) ? String(x2) : x2.toFixed(1);
-const signed = (x2) => (x2 > 0 ? "+" : "") + fmt$1(x2);
-const clamp01 = (x2) => x2 < 0 ? 0 : x2 > 1 ? 1 : x2;
-const mean2 = (xs) => xs.length ? xs.reduce((a2, b2) => a2 + b2, 0) / xs.length : 0;
-const std = (xs) => {
-  if (xs.length < 2) return 0;
-  const m2 = mean2(xs);
-  return Math.sqrt(xs.reduce((a2, b2) => a2 + (b2 - m2) * (b2 - m2), 0) / xs.length);
+const fmt$1 = (x2) => {
+  const r2 = Number.isInteger(x2) ? String(x2) : x2.toFixed(1);
+  return r2 === "-0.0" ? "0.0" : r2;
+};
+const signed = (x2) => {
+  const f2 = fmt$1(x2);
+  return f2 === "0" || f2 === "0.0" || f2.startsWith("-") ? f2 : `+${f2}`;
 };
+const clamp01 = (x2) => x2 < 0 ? 0 : x2 > 1 ? 1 : x2;
 function band(absStd) {
   if (absStd >= 0.66) return { level: "large gap", tone: "neg" };
   if (absStd >= 0.33) return { level: "some", tone: "warn" };
@@ -59202,11 +60154,22 @@ const kindOf = (cols, name) => {
   var _a2;
   return (_a2 = cols.find((c2) => c2.name === name)) == null ? void 0 : _a2.kind;
 };
-function populationFieldIds(spec) {
-  return (getOpt(spec.population) ?? []).map((p2) => {
-    var _a2;
-    return (_a2 = p2.value) == null ? void 0 : _a2.fieldId;
-  }).filter((id3) => typeof id3 === "string");
+const VERDICT_TONE = {
+  causal: "pos",
+  modest: "warn",
+  adjustment_insufficient: "warn",
+  non_identifiable_positivity: "neg",
+  not_estimable: "muted"
+};
+const VERDICT_LABEL = {
+  causal: "Causal effect",
+  modest: "Modest / unclear",
+  adjustment_insufficient: "Not trustworthy yet",
+  non_identifiable_positivity: "No fair comparison",
+  not_estimable: "Can’t be estimated"
+};
+function deriveVerdict(v3) {
+  return { tag: v3.type, tone: VERDICT_TONE[v3.type], label: VERDICT_LABEL[v3.type] };
 }
 function treatmentKind(cols, treatment) {
   switch (kindOf(cols, treatment)) {
@@ -59222,124 +60185,133 @@ function treatmentKind(cols, treatment) {
       return "value";
   }
 }
-function deriveSpec(spec, cols, result, meta3, dataLen) {
-  const tKind = kindOf(cols, spec.treatment);
-  const outUnit = unitOf(meta3, spec.outcome);
-  const balByCol = new Map(((result == null ? void 0 : result.balance) ?? []).map((b2) => [b2.column, b2]));
-  const confounders = spec.confounders.map((col) => {
+function deriveSpec(config2, cols, result, meta3, dataLen) {
+  const tKind = kindOf(cols, config2.treatment);
+  const outUnit = unitOf(meta3, config2.outcome);
+  const balByCol = /* @__PURE__ */ new Map();
+  for (const b2 of (result == null ? void 0 : result.balance) ?? []) {
+    const prev2 = balByCol.get(b2.base_column);
+    if (!prev2 || Math.abs(b2.std_diff) > Math.abs(prev2.std_diff)) balByCol.set(b2.base_column, b2);
+  }
+  const confounders = config2.common_causes.map((col) => {
     const b2 = balByCol.get(col);
-    const absStd = b2 ? Math.abs(b2.stdDiff) : 0;
+    const absStd = b2 ? Math.abs(b2.std_diff) : 0;
     const { level, tone } = band(absStd);
-    const dir = b2 ? b2.treatedMean < b2.controlMean ? "lower" : "higher" : "";
-    const reason = b2 ? `treated batches ran ${dir} on ${col}` : "measured once you Run";
+    const dir = b2 ? b2.treated_mean < b2.control_mean ? "lower" : "higher" : "";
+    const reason = b2 ? `the treated group ran ${dir} on ${col}` : "measured once you Run";
     return { col, reason, imbalance: clamp01(absStd), level, tone };
   });
-  const inPlay = /* @__PURE__ */ new Set([spec.treatment, spec.outcome, ...spec.confounders, ...populationFieldIds(spec)]);
+  const inPlay = /* @__PURE__ */ new Set([config2.treatment, config2.outcome, ...config2.common_causes]);
   const suggest = cols.find((c2) => !inPlay.has(c2.name));
   const suggestion = suggest ? `add ${suggest.name}` : "";
-  const methodV = getOpt(spec.method);
+  const methodV = getOpt(config2.method);
   const method = (methodV == null ? void 0 : methodV.type) === "propensity_score_weighting" ? "reweighting" : "regression";
-  const targetV = getOpt(spec.targetUnits);
+  const targetV = getOpt(config2.estimand);
   const target = targetV && (targetV.type === "att" || targetV.type === "atc") ? "treated" : "all";
-  const trim2 = getOpt(spec.trim) !== void 0;
   return {
-    treatment: spec.treatment,
-    treatmentKind: treatmentKind(cols, spec.treatment),
-    outcome: spec.outcome,
+    treatment: config2.treatment,
+    treatmentKind: treatmentKind(cols, config2.treatment),
+    outcome: config2.outcome,
     outcomeKind: outUnit ? `number · ${outUnit}` : "number",
     comparison: tKind === "boolean" ? "yes · vs no" : "high · vs low",
     confounders,
     suggestion,
     method,
     target,
-    trim: trim2,
-    dataLabel: `${result ? Number(result.nTotal) : dataLen} rows`
+    dataLabel: `${result ? Number(result.n_total) : dataLen} rows`
   };
 }
 function balanceDisplay(b2, categorical) {
-  const isProp = categorical.has(b2.column) && b2.treatedMean >= 0 && b2.treatedMean <= 1 && b2.controlMean >= 0 && b2.controlMean <= 1;
-  return isProp ? `${Math.round(b2.treatedMean * 100)}% vs ${Math.round(b2.controlMean * 100)}%` : `${b2.treatedMean.toFixed(1)} vs ${b2.controlMean.toFixed(1)}`;
-}
-function deriveAnswer(spec, result, meta3) {
-  const ci = getOpt(result.ci);
-  const nci = getOpt(result.naiveCi);
-  const categorical = new Set(spec.categorical);
-  const balance = [...result.balance].sort((a2, b2) => Math.abs(b2.stdDiff) - Math.abs(a2.stdDiff)).map((b2) => ({
+  const isProp = categorical.has(b2.base_column) && b2.treated_mean >= 0 && b2.treated_mean <= 1 && b2.control_mean >= 0 && b2.control_mean <= 1;
+  return isProp ? `${Math.round(b2.treated_mean * 100)}% vs ${Math.round(b2.control_mean * 100)}%` : `${b2.treated_mean.toFixed(1)} vs ${b2.control_mean.toFixed(1)}`;
+}
+function deriveAnswer(config2, result, adj, meta3) {
+  const ci = getOpt(adj.ci);
+  const nci = getOpt(result.naive_ci);
+  const categorical = new Set(getOpt(config2.categorical) ?? []);
+  const balance = [...result.balance].sort((a2, b2) => Math.abs(b2.std_diff) - Math.abs(a2.std_diff)).map((b2) => ({
     col: b2.column,
-    treated: b2.treatedMean,
-    control: b2.controlMean,
+    treated: b2.treated_mean,
+    control: b2.control_mean,
     display: balanceDisplay(b2, categorical),
-    frac: clamp01(Math.abs(b2.stdDiff)),
-    tone: band(Math.abs(b2.stdDiff)).tone
+    frac: clamp01(Math.abs(b2.std_diff)),
+    tone: band(Math.abs(b2.std_diff)).tone
   }));
-  const nDropped = Number(result.nDropped);
-  const nTotal = Number(result.nTotal);
+  const lo2 = (ci == null ? void 0 : ci.lower) ?? adj.effect;
+  const hi = (ci == null ? void 0 : ci.upper) ?? adj.effect;
+  const clear = result.verdict.type === "causal" || (ci ? lo2 > 0 || hi < 0 : false);
+  const flip = Math.sign(result.naive) !== Math.sign(adj.effect) && result.naive !== 0;
+  const nDropped = Number(result.n_dropped);
+  const nTotal = Number(result.n_total);
   return {
-    treatment: spec.treatment,
-    outcome: spec.outcome,
-    unit: unitOf(meta3, spec.outcome),
+    treatment: config2.treatment,
+    outcome: config2.outcome,
+    unit: unitOf(meta3, config2.outcome),
     naive: result.naive,
     naiveLo: (nci == null ? void 0 : nci.lower) ?? result.naive,
     naiveHi: (nci == null ? void 0 : nci.upper) ?? result.naive,
-    effect: result.effect,
-    lo: (ci == null ? void 0 : ci.lower) ?? result.effect,
-    hi: (ci == null ? void 0 : ci.upper) ?? result.effect,
-    nTotal: result.nTotal,
-    nTreated: result.nTreated,
-    nControl: result.nControl,
+    effect: adj.effect,
+    lo: lo2,
+    hi,
+    clear,
+    flip,
+    cautious: result.verdict.type === "adjustment_insufficient",
+    nTotal: result.n_total,
+    nTreated: result.n_treated,
+    nControl: result.n_control,
     nCompared: BigInt(Math.max(0, nTotal - nDropped)),
-    nDropped: result.nDropped,
+    nDropped: result.n_dropped,
     balance
   };
 }
-function deriveRefuteCheck(c2) {
-  const effects = arr(c2.newEffects);
-  const m2 = mean2(effects);
-  const est = c2.estimatedEffect;
-  switch (c2.kind.type) {
-    case "placebo": {
-      const passed = Math.abs(m2) < Math.max(0.5, Math.abs(est) * 0.15);
-      return {
-        name: "Shuffle test",
-        desc: "Shuffle which rows were treated; a real effect should collapse to zero.",
-        value: `→ ${signed(m2)}`,
-        passed,
-        tip: { type: "some", value: "Randomly re-label which rows were treated. A genuine effect should vanish." }
-      };
-    }
-    case "data_subset": {
-      const passed = Math.abs(m2 - est) < Math.max(0.5, Math.abs(est) * 0.2);
-      return {
-        name: "Drop-some test",
-        desc: "Re-estimate on random subsamples; a trustworthy effect stays put.",
-        value: `${fmt$1(m2)} ± ${fmt$1(std(effects))}`,
-        passed,
-        tip: { type: "none", value: null }
-      };
-    }
-    case "random_common_cause": {
-      const passed = Math.abs(m2 - est) < Math.max(0.5, Math.abs(est) * 0.2);
-      return {
-        name: "Decoy cause",
-        desc: "Add an irrelevant random factor; the answer should not move.",
-        value: `${fmt$1(est)} → ${fmt$1(m2)}`,
-        passed,
-        tip: { type: "none", value: null }
-      };
-    }
-    default: {
-      const strengths = arr(getOpt(c2.strengths));
-      const tip = zeroCrossing(strengths, effects);
-      const passed = tip === null;
-      return {
-        name: "Hidden cause",
-        desc: "How strong an unrecorded common cause would need to be to overturn the result.",
-        value: tip === null ? "holds throughout" : `tips at ${fmt$1(tip)}`,
-        passed,
-        tip: { type: "some", value: "Something unrecorded could drive both the treatment choice and the outcome." }
-      };
-    }
+function deriveRefusal(config2, result) {
+  const nT = Number(result.n_treated), nC = Number(result.n_control), nTot = Number(result.n_total);
+  if (result.verdict.type === "not_estimable") {
+    const reason = result.verdict.value || "The treatment barely varies, so no comparison can be formed.";
+    return {
+      kind: "not_estimable",
+      title: `Can’t estimate the effect of ${config2.treatment}`,
+      body: reason,
+      evidence: [
+        { label: "treated", value: String(nT) },
+        { label: "untreated", value: String(nC) },
+        { label: "rows", value: String(nTot) }
+      ]
+    };
+  }
+  if (result.verdict.type === "non_identifiable_positivity") {
+    const pct = Math.round(result.overlap.common_support_frac * 100);
+    return {
+      kind: "positivity",
+      title: "No like-for-like comparison exists",
+      body: `The treated and untreated groups barely overlap on the confounders — only ${pct}% sit in a range where both occur — so there is no fair comparison to adjust toward.`,
+      evidence: [
+        { label: "common support", value: `${pct}%` },
+        { label: "treated", value: String(nT) },
+        { label: "untreated", value: String(nC) }
+      ]
+    };
   }
+  return {
+    kind: "not_estimable",
+    title: `Can’t estimate the effect of ${config2.treatment}`,
+    body: "The engine could not produce a like-for-like estimate for this configuration.",
+    evidence: [
+      { label: "treated", value: String(nT) },
+      { label: "untreated", value: String(nC) },
+      { label: "rows", value: String(nTot) }
+    ]
+  };
+}
+function deriveOverlap(o2) {
+  const pct = Math.round(o2.common_support_frac * 100);
+  return {
+    treated: arr(o2.treated_propensity),
+    control: arr(o2.control_propensity),
+    commonSupportFrac: o2.common_support_frac,
+    positivityOk: o2.positivity_ok,
+    supportLabel: `${pct}% common support`
+  };
 }
 function zeroCrossing(xs, ys) {
   for (let i = 1; i < ys.length && i < xs.length; i++) {
@@ -59351,27 +60323,80 @@ function zeroCrossing(xs, ys) {
   }
   return null;
 }
-function deriveRefute(refute, result) {
-  const checks = refute.checks.map(deriveRefuteCheck);
-  const uc = refute.checks.find((c2) => c2.kind.type === "unobserved");
-  const ci = getOpt(result.ci);
-  const half = ci ? Math.abs(ci.upper - ci.lower) / 2 : 0;
-  const mid = uc ? arr(uc.newEffects) : [];
-  const strengths = uc ? arr(getOpt(uc.strengths)) : [];
-  const sensLo = mid.map((m2) => m2 - half);
-  const sensHi = mid.map((m2) => m2 + half);
-  const xTicks = strengths.length ? [strengths[0], strengths[Math.floor(strengths.length / 2)], strengths[strengths.length - 1]].map((_2, i) => ["none", "weaker", "stronger"][i]) : ["none", "weaker", "stronger"];
-  const lo2 = Math.min(0, ...sensLo), hi = Math.max(...sensHi, 0);
-  const yTicks = [fmt$1(lo2), fmt$1((lo2 + hi) / 2), fmt$1(hi)];
-  return { checks, sensLo, sensMid: mid, sensHi, sensXTicks: xTicks, sensYTicks: yTicks };
-}
-function deriveDose(dose, spec, meta3) {
-  var _a2;
+function deriveRefute(r2, adj) {
+  const checks = [];
+  const est = (adj == null ? void 0 : adj.effect) ?? 0;
+  const placeboEffect = getOpt(r2.placebo_effect);
+  const placeboPasses = getOpt(r2.placebo_passes);
+  if (placeboEffect !== void 0 || placeboPasses !== void 0) {
+    checks.push({
+      name: "Shuffle test",
+      desc: "Shuffle which rows were treated; a real effect should collapse to zero.",
+      value: placeboEffect !== void 0 ? `→ ${signed(placeboEffect)}` : placeboPasses ? "passed" : "failed",
+      passed: placeboPasses ?? (placeboEffect !== void 0 && Math.abs(placeboEffect) < Math.max(0.5, Math.abs(est) * 0.15)),
+      tip: { type: "some", value: "Randomly re-label which rows were treated. A genuine effect should vanish." },
+      help: "check_shuffle"
+    });
+  }
+  const ds = getOpt(r2.data_subset_effect);
+  if (ds !== void 0) {
+    const dstd = getOpt(r2.data_subset_std) ?? 0;
+    checks.push({
+      name: "Drop-some test",
+      desc: "Re-estimate on random subsamples; a trustworthy effect stays put.",
+      value: `${fmt$1(ds)} ± ${fmt$1(dstd)}`,
+      passed: Math.abs(ds - est) < Math.max(0.5, Math.abs(est) * 0.2),
+      tip: { type: "none", value: null },
+      help: "check_dropsome"
+    });
+  }
+  const rcc = getOpt(r2.random_cc_within_ci);
+  if (rcc !== void 0) {
+    checks.push({
+      name: "Decoy cause",
+      desc: "Add an irrelevant random factor; the answer should not move.",
+      value: rcc ? "within range" : "moved",
+      passed: rcc,
+      tip: { type: "none", value: null },
+      help: "check_decoy"
+    });
+  }
+  const sens = getOpt(r2.sensitivity);
+  const evalue = getOpt(r2.robustness_value);
+  if (sens !== void 0 || evalue !== void 0) {
+    const strengths = sens ? arr(sens.strengths) : [];
+    const effects = sens ? arr(sens.effects) : [];
+    const tip = sens ? zeroCrossing(strengths, effects) : null;
+    const value = tip !== null ? `tips at ${fmt$1(tip)}` : evalue !== void 0 ? `E-value ${fmt$1(evalue)}` : "holds throughout";
+    checks.push({
+      name: "Hidden cause",
+      desc: "How strong an unrecorded common cause would need to be to overturn the result.",
+      value,
+      passed: tip === null,
+      tip: { type: "some", value: "Something unrecorded could drive both the treatment choice and the outcome." },
+      help: "check_hidden"
+    });
+  }
+  let sensVM = null;
+  if (sens !== void 0) {
+    const mid = arr(sens.effects);
+    if (mid.length) {
+      const ci = getOpt(adj == null ? void 0 : adj.ci);
+      const half = ci ? Math.abs(ci.upper - ci.lower) / 2 : 0;
+      const lo2 = mid.map((m2) => m2 - half);
+      const hi = mid.map((m2) => m2 + half);
+      const yLo = Math.min(0, ...lo2), yHi = Math.max(...hi, 0);
+      sensVM = { lo: lo2, mid, hi, xTicks: ["none", "weaker", "stronger"], yTicks: [fmt$1(yLo), fmt$1((yLo + yHi) / 2), fmt$1(yHi)] };
+    }
+  }
+  return { checks, sens: sensVM };
+}
+function deriveDose(dose, config2, meta3) {
   const grid = arr(dose.grid);
   const mid = arr(dose.effect);
   const lo2 = getOpt(dose.lower) ? arr(getOpt(dose.lower)) : mid.slice();
   const hi = getOpt(dose.upper) ? arr(getOpt(dose.upper)) : mid.slice();
-  const sizes = dose.size ? Array.from(dose.size, Number) : [];
+  const sizes = arrI(dose.size);
   const featureUnit = unitOf(meta3, dose.feature);
   const here = sizes.length ? sizes.indexOf(Math.max(...sizes)) : 0;
   const marg = mid.map((m2, i) => i === 0 ? 0 : m2 - mid[i - 1]);
@@ -59391,31 +60416,28 @@ function deriveDose(dose, spec, meta3) {
   let lastStep = margSteps.length - 1;
   while (lastStep > 0 && Math.abs(margSteps[lastStep]) < 0.12 * maxMarg) lastStep--;
   const marginal = margSteps.slice(0, lastStep + 1).map((v3, i) => ({ label: `${fmt$1(grid[i + 1])}`, value: v3, frac: clamp01(Math.abs(v3) / maxMarg) }));
-  const segLabels = ((_a2 = getOpt(dose.segments)) == null ? void 0 : _a2.map((s2) => s2.label)) ?? [];
-  const segments = segLabels.length ? ["all", ...segLabels] : ["all"];
   const stepFrom = here < sweet ? here : Math.max(0, sweet - 1);
   const gainToSweet = (mid[sweet] ?? 0) - (mid[stepFrom] ?? 0);
   const nextGain = sweet + 1 < mid.length ? mid[sweet + 1] - mid[sweet] : 0;
   const tradeoff = `Going from ${fmt$1(grid[stepFrom] ?? 0)} to ${fmt$1(grid[sweet] ?? 0)} adds ${signed(gainToSweet)}; the next step adds only ${signed(nextGain)}.`;
+  const marks = [];
+  if (sizes.length) marks.push({ at: here, label: "you are here", tone: "muted", help: "dose_here" });
+  marks.push({ at: sweet, label: "sweet spot", tone: "pos", help: "dose_sweet" });
   return {
     feature: dose.feature,
-    outcome: spec.outcome,
+    outcome: config2.outcome,
     lo: lo2,
     mid,
     hi,
     xTicks,
     yTicks,
-    marks: [
-      { at: BigInt(here), label: "you are here", tone: "muted" },
-      { at: BigInt(sweet), label: "sweet spot", tone: "pos" }
-    ],
+    marks,
     recoLabel: `≈ ${fmt$1(grid[sweet] ?? 0)}${featureUnit ? " " + featureUnit : ""}`,
     recoEffect: mid[sweet] ?? 0,
     recoLo: lo2[sweet] ?? 0,
     recoHi: hi[sweet] ?? 0,
     tradeoff,
-    marginal,
-    segments
+    marginal
   };
 }
 function relTime(d2, now2) {
@@ -59425,30 +60447,126 @@ function relTime(d2, now2) {
   if (days < 7) return d2.toLocaleDateString(void 0, { weekday: "short" });
   return "last wk";
 }
+const VERDICT_WORD = {
+  causal: "causal",
+  modest: "modest",
+  adjustment_insufficient: "not robust",
+  non_identifiable_positivity: "no overlap",
+  not_estimable: "n/a"
+};
 function deriveJournalRow(row, now2) {
-  const ci = getOpt(row.ci);
-  const clear = ci ? ci.lower > 0 || ci.upper < 0 : true;
-  const dirUp = row.effect > 0;
+  const adj = getOpt(row.adjusted);
   return {
-    treatment: row.spec.treatment,
-    outcome: row.spec.outcome,
-    confounders: row.spec.confounders.join(", "),
-    effect: signed(row.effect),
-    verdict: clear ? dirUp ? "higher" : "lower" : "no clear effect",
-    verdictTone: clear ? "pos" : "warn",
-    who: row.committedBy,
-    when: relTime(row.committedAt, now2)
-  };
-}
-function deriveView(spec, cols, result, refute, dose, journal, meta3, dataLen, now2) {
+    treatment: row.config.treatment,
+    outcome: row.config.outcome,
+    confounders: row.config.common_causes.join(", "),
+    effect: adj !== void 0 ? signed(adj) : signed(row.naive),
+    verdict: VERDICT_WORD[row.verdict.type],
+    verdictTone: VERDICT_TONE[row.verdict.type],
+    who: row.committed_by,
+    when: relTime(row.committed_at, now2)
+  };
+}
+function deriveView(config2, ranConfig, cols, result, journal, meta3, dataLen, now2) {
+  const adj = result ? getOpt(result.adjusted) : void 0;
+  const refutation = result ? getOpt(result.refutation) : void 0;
+  const doseR = result ? getOpt(result.dose_response) : void 0;
   return {
-    spec: deriveSpec(spec, cols, result, meta3, dataLen),
-    answer: result ? deriveAnswer(spec, result, meta3) : null,
-    refute: refute && result ? deriveRefute(refute, result) : null,
-    dose: dose ? deriveDose(dose, spec, meta3) : null,
+    // The set-up rail reflects the LIVE config (the editor); the result deck
+    // reflects RANCONFIG — the config that produced `result` — so the result
+    // strings never drift ahead of the numbers on a live picker edit.
+    spec: deriveSpec(config2, cols, result, meta3, dataLen),
+    verdict: result ? deriveVerdict(result.verdict) : null,
+    answer: result && adj ? deriveAnswer(ranConfig, result, adj, meta3) : null,
+    refusal: result && !adj ? deriveRefusal(ranConfig, result) : null,
+    overlap: result ? deriveOverlap(result.overlap) : null,
+    refute: refutation ? deriveRefute(refutation, adj) : null,
+    dose: doseR && doseR.effect.length ? deriveDose(doseR, ranConfig, meta3) : null,
     journal: journal ? journal.map((r2) => deriveJournalRow(r2, now2)) : null
   };
 }
+const DESIGN_HEADLINE = {
+  detect_observed: "Confirm it with a controlled trial",
+  de_bias: "Make it trustworthy with a controlled trial",
+  resolve_vs_null: "Settle it with a bigger trial",
+  restrict_to_overlap: "You can’t compare yet",
+  create_control: "Hold some back next time"
+};
+function deriveDesignOption(o2) {
+  return {
+    label: o2.label,
+    nTotal: Number(o2.n_total),
+    nTreated: Number(o2.n_treated),
+    nControl: Number(o2.n_control),
+    treatedShare: o2.treated_share
+  };
+}
+function deriveDesign(d2, result, ranConfig, meta3) {
+  const basis = d2.basis.type;
+  const outcome = ranConfig.outcome;
+  const unit2 = unitOf(meta3, outcome);
+  const options2 = d2.options.map(deriveDesignOption);
+  const primary = options2[0] ?? { label: "Even split", nTotal: 0, nTreated: 0, nControl: 0, treatedShare: 0.5 };
+  const balByCol = /* @__PURE__ */ new Map();
+  for (const b2 of (result == null ? void 0 : result.balance) ?? []) {
+    const prev2 = balByCol.get(b2.base_column);
+    if (!prev2 || Math.abs(b2.std_diff) > Math.abs(prev2.std_diff)) balByCol.set(b2.base_column, b2);
+  }
+  const matchOn = d2.match_on.map((col) => {
+    var _a2;
+    const b2 = balByCol.get(col);
+    const absStd = b2 ? Math.abs(b2.std_diff) : 0;
+    const { tone } = band(absStd);
+    return { col, frac: clamp01(absStd), tone, display: getOpt((_a2 = colMeta(meta3, col)) == null ? void 0 : _a2.label) ?? col };
+  });
+  const ns = arrI(d2.power_curve.n);
+  const powers = arr(d2.power_curve.power);
+  const len = Math.min(ns.length, powers.length);
+  const nearest = (target) => {
+    let bi = 0, bd = Infinity;
+    for (let i = 0; i < len; i++) {
+      const dd = Math.abs(ns[i] - target);
+      if (dd < bd) {
+        bd = dd;
+        bi = i;
+      }
+    }
+    return bi;
+  };
+  const xTicks = len ? [String(ns[0]), String(ns[Math.floor((len - 1) / 2)]), String(ns[len - 1])] : [];
+  const marks = [];
+  if (len) marks.push({ at: nearest(primary.nTotal), label: `target ${(d2.target_power * 100).toFixed(0)}%`, tone: "pos", help: "validate_power" });
+  const cp = getOpt(d2.current_power);
+  if (cp !== void 0 && len) {
+    const curN = result ? Number(result.n_total) : 0;
+    if (curN > 0) {
+      const offScale = curN >= (ns[len - 1] ?? 0);
+      marks.push({
+        at: offScale ? len - 1 : nearest(curN),
+        label: offScale ? `you’re here · ${(cp * 100).toFixed(0)}% (off-scale)` : `you’re here ${(cp * 100).toFixed(0)}%`,
+        tone: "muted",
+        help: "validate_power"
+      });
+    }
+  }
+  const faint = d2.outcome_sd > 0 && Math.abs(d2.target_effect) / d2.outcome_sd <= 0.011;
+  return {
+    headline: DESIGN_HEADLINE[basis] ?? "Validate this",
+    rationale: d2.rationale,
+    primary,
+    alternates: options2.slice(1),
+    matchOn,
+    curve: { mid: powers.slice(0, len).map((p2) => p2 * 100), xTicks, marks },
+    targetLabel: `${signed(d2.target_effect)}${unit2 ? ` ${unit2}` : ""}`,
+    targetPctLabel: `${(d2.target_power * 100).toFixed(0)}%`,
+    holdback: basis === "create_control",
+    showOverlap: basis === "restrict_to_overlap",
+    faint
+  };
+}
+const SUBJECT_ONE = "record";
+const SUBJECT_MANY = "records";
+const AUTORUN_MAX_ROWS = 5e4;
 const TONE_TOKEN = {
   neg: "fg.danger",
   pos: "fg.success",
@@ -59486,13 +60604,73 @@ function useColumns(workspace, source) {
     };
   }, [types == null ? void 0 : types.sourceType]);
 }
-const STR_TYPE = east.variant("String", null);
-function Cap({ children: children2 }) {
-  return /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", fontSize: "9px", display: "flex", alignItems: "center", gap: "1.5", mb: "2.5", children: children2 });
+function rowMatchesAll(row, preds) {
+  return preds.every((p2) => {
+    const { fieldId, op } = p2.value;
+    const v3 = row[fieldId];
+    const ov = op.value;
+    switch (op.type) {
+      case "eq":
+      case "is":
+        return v3 === ov;
+      case "neq":
+        return v3 !== ov;
+      case "lt":
+        return num(v3) != null && num(ov) != null ? num(v3) < num(ov) : true;
+      case "lte":
+        return num(v3) != null && num(ov) != null ? num(v3) <= num(ov) : true;
+      case "gt":
+        return num(v3) != null && num(ov) != null ? num(v3) > num(ov) : true;
+      case "gte":
+        return num(v3) != null && num(ov) != null ? num(v3) >= num(ov) : true;
+      case "in":
+        return ov instanceof Set ? ov.has(v3) : true;
+      case "notIn":
+        return ov instanceof Set ? !ov.has(v3) : true;
+      default:
+        return true;
+    }
+  });
+}
+const num = (x2) => typeof x2 === "number" ? x2 : typeof x2 === "bigint" ? Number(x2) : null;
+function Cap({ children: children2, help }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", fontSize: "9px", mb: "2.5", children: help ? /* @__PURE__ */ jsxRuntime.jsx(Help, { id: help, children: children2 }) : children2 });
 }
 function Card({ children: children2, mt = "3" }) {
   return /* @__PURE__ */ jsxRuntime.jsx(react.Box, { layerStyle: "card", p: "3.5", borderRadius: "lg", mt, children: children2 });
 }
+function RunError({ error: error3 }) {
+  const tail = (error3.stderr || error3.stdout || "").trim().split("\n").slice(-12).join("\n");
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "banner.stale", display: "flex", flexDirection: "column", gap: "2", mt: "3", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "inline-flex", alignItems: "flex-start", gap: "2", color: "fg.danger", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", mt: "0.5", fontSize: "12px", flexShrink: "0", children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faTriangleExclamation }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "body.sm", color: "fg.default", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "bold", children: "Could not run the experiment." }),
+        " ",
+        error3.message
+      ] })
+    ] }),
+    tail && /* @__PURE__ */ jsxRuntime.jsx(
+      react.Box,
+      {
+        as: "pre",
+        m: "0",
+        p: "2",
+        maxH: "160px",
+        overflow: "auto",
+        bg: "bg.canvas",
+        borderRadius: "md",
+        borderWidth: "1px",
+        borderColor: "border.subtle",
+        fontFamily: "mono",
+        fontSize: "11px",
+        color: "fg.muted",
+        whiteSpace: "pre-wrap",
+        children: tail
+      }
+    )
+  ] });
+}
 function ActionButton({ button, variant: variant2, label, onClick, disabled: disabled2, pulse = false }) {
   return /* @__PURE__ */ jsxRuntime.jsx(
     react.Box,
@@ -59508,8 +60686,46 @@ function ActionButton({ button, variant: variant2, label, onClick, disabled: dis
     }
   );
 }
+function DeckSkeleton({ tab }) {
+  const sk = react.useRecipe({ key: "skeleton" });
+  const bar = (w2, h2) => /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: sk({ variant: "line" }), width: w2, height: h2 });
+  const block = (h2) => /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: sk({ variant: "block" }), width: "100%", minHeight: h2 });
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", display: "flex", flexDirection: "column", gap: "4", children: [
+    tab === "answer" && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", gap: "4.5", alignItems: "flex-end", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "2", children: [
+          bar("64px", "10px"),
+          bar("120px", "32px")
+        ] }),
+        bar("170px", "24px")
+      ] }),
+      block("120px"),
+      block("120px")
+    ] }),
+    tab === "trust" && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      bar("70%", "14px"),
+      block("160px")
+    ] }),
+    tab === "dose" && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      block("240px"),
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "1fr 1fr", gap: "3", children: [
+        block("90px"),
+        block("90px")
+      ] })
+    ] }),
+    tab === "validate" && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", gap: "5", alignItems: "flex-end", children: [
+        bar("120px", "32px"),
+        bar("200px", "10px")
+      ] }),
+      block("110px"),
+      block("150px")
+    ] })
+  ] });
+}
+const experimentValueEqual = east.equalFor(internal.Experiment.Component.schema);
 const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }) {
-  var _a2, _b2, _c2;
+  var _a2, _b2, _c2, _d2;
   const v3 = value;
   const button = react.useRecipe({ key: "button" });
   const chip = react.useRecipe({ key: "chip" });
@@ -59519,12 +60735,19 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
   const es = react.useSlotRecipe({ key: "eyebrowRow" })({});
   const workspace = getReactiveDatasetCache().getConfig().workspace ?? "";
   const data4 = useBindingValue(v3.data);
-  const specBind = useBindingValue(v3.spec);
+  const configBind = useBindingValue(v3.config);
   const journalBind = useBindingValue(v3.journal.type === "some" ? v3.journal.value : null);
+  const populationBind = useBindingValue(v3.population.type === "some" ? v3.population.value : null);
   const meta3 = getOpt(v3.columnMeta);
   const readonly = getOpt(v3.readonly) ?? false;
   const { columns, rowArrayType } = useColumns(workspace, v3.data.source);
-  const spec = specBind.value;
+  const config2 = configBind.value;
+  const [localPop, setLocalPop] = React.useState([]);
+  const population = populationBind.value ?? localPop;
+  const filteredRows = React.useMemo(() => {
+    if (!data4.value) return null;
+    return population.length ? data4.value.filter((r2) => rowMatchesAll(r2, population)) : data4.value;
+  }, [data4.value, population]);
   const fields = React.useMemo(
     () => columns.filter((c2) => c2.kind !== "other").map((c2) => {
       var _a3;
@@ -59536,132 +60759,176 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
     }),
     [columns, meta3]
   );
-  const estInputs = React.useMemo(() => rowArrayType ? [rowArrayType, internal.Experiment.Types.Spec] : null, [rowArrayType]);
-  const doseInputs = React.useMemo(() => rowArrayType ? [rowArrayType, internal.Experiment.Types.Spec, east.fromEastTypeValue(STR_TYPE)] : null, [rowArrayType]);
-  const estimate = useFuncCall(v3.estimate.name, estInputs, internal.Experiment.Types.Result);
-  const refute = useFuncCall(v3.refute.type === "some" ? v3.refute.value.name : null, estInputs, internal.Experiment.Types.Refute);
-  const dose = useFuncCall(v3.dose.type === "some" ? v3.dose.value.name : null, doseInputs, internal.Experiment.Types.Dose);
-  const doseFeature = React.useMemo(() => {
-    if (!spec) return "";
-    const f2 = columns.find((c2) => c2.kind === "float" && c2.name !== spec.outcome);
-    return (f2 == null ? void 0 : f2.name) ?? spec.treatment;
-  }, [columns, spec]);
+  const estInputs = React.useMemo(() => rowArrayType ? [rowArrayType, internal.Experiment.Types.Config] : null, [rowArrayType]);
+  const experiment = useFuncCall(v3.experiment.name, estInputs, internal.Experiment.Types.Result);
+  const hasDesign = v3.design.type === "some";
+  const designInputs = React.useMemo(
+    () => rowArrayType ? [rowArrayType, internal.Experiment.Types.Config, internal.Experiment.Types.Result, internal.Experiment.Types.DesignConfig] : null,
+    [rowArrayType]
+  );
+  const design = useFuncCall(v3.design.type === "some" ? v3.design.value.name : null, designInputs, internal.Experiment.Types.Design);
+  const pendingConfigRef = React.useRef(null);
+  const [ranConfig, setRanConfig] = React.useState(null);
   const runAll = React.useCallback(() => {
-    if (!data4.value || !spec) return;
-    estimate.call(data4.value, spec);
-    if (v3.refute.type === "some") refute.call(data4.value, spec);
-    if (v3.dose.type === "some") dose.call(data4.value, spec, doseFeature);
-  }, [data4.value, spec, estimate, refute, dose, doseFeature, v3.refute.type, v3.dose.type]);
+    if (!filteredRows || !config2) return;
+    pendingConfigRef.current = config2;
+    experiment.call(filteredRows, config2);
+  }, [filteredRows, config2, experiment]);
   const autoRan = React.useRef(false);
   React.useEffect(() => {
     if (autoRan.current) return;
-    if (!data4.value || !spec || !rowArrayType) return;
-    if (estimate.result !== null || estimate.status === "running") {
+    if (!filteredRows || !config2 || !rowArrayType) return;
+    if (experiment.result !== null || experiment.status === "running") {
       autoRan.current = true;
       return;
     }
-    if (estimate.status !== "idle") return;
+    if (experiment.status !== "idle") return;
     autoRan.current = true;
+    if (filteredRows.length > AUTORUN_MAX_ROWS) return;
     runAll();
-  }, [data4.value, spec, rowArrayType, estimate.result, estimate.status, runAll]);
+  }, [filteredRows, config2, rowArrayType, experiment.result, experiment.status, runAll]);
+  React.useEffect(() => {
+    if (experiment.result !== null) setRanConfig(pendingConfigRef.current);
+  }, [experiment.result]);
   const [stale, setStale] = React.useState(false);
-  const editSpec = React.useCallback((next2) => {
+  const editConfig = React.useCallback((next2) => {
+    if (readonly) return;
+    setStale(true);
+    queueMicrotask(() => configBind.mutate(next2));
+  }, [readonly, configBind]);
+  const editPopulation = React.useCallback((next2) => {
+    if (readonly) return;
     setStale(true);
-    queueMicrotask(() => specBind.mutate(next2));
-  }, [specBind]);
+    if (v3.population.type === "some") queueMicrotask(() => populationBind.mutate(next2));
+    else setLocalPop(next2);
+  }, [readonly, v3.population.type, populationBind]);
   const onRun = React.useCallback(() => {
     runAll();
     setStale(false);
   }, [runAll]);
   const onCommit = React.useCallback(async () => {
-    if (!spec || !estimate.result) return;
-    const row = { spec, effect: estimate.result.effect, ci: estimate.result.ci, committedAt: /* @__PURE__ */ new Date(), committedBy: "you" };
+    if (!config2 || !experiment.result) return;
+    const r2 = experiment.result;
+    const row = {
+      config: config2,
+      verdict: r2.verdict,
+      naive: r2.naive,
+      adjusted: r2.adjusted.type === "some" ? east.some(r2.adjusted.value.effect) : east.none,
+      committed_at: /* @__PURE__ */ new Date(),
+      committed_by: "you"
+    };
     journalBind.mutate([row, ...journalBind.value ?? []]);
     try {
       await journalBind.commit();
-      await specBind.commit();
+      await configBind.commit();
+      if (v3.population.type === "some") await populationBind.commit();
       setStale(false);
     } catch {
     }
-  }, [spec, estimate.result, journalBind, specBind]);
+  }, [config2, experiment.result, journalBind, configBind, populationBind, v3.population.type]);
   const [tab, setTab] = React.useState(((_a2 = getOpt(v3.defaultTab)) == null ? void 0 : _a2.type) ?? "answer");
+  const [guidance, setGuidance] = React.useState(true);
   const now2 = React.useMemo(() => /* @__PURE__ */ new Date(), []);
-  const nRows = ((_b2 = data4.value) == null ? void 0 : _b2.length) ?? 0;
+  const nRows = (filteredRows == null ? void 0 : filteredRows.length) ?? 0;
+  const helpVars = React.useMemo(() => {
+    const rc = ranConfig ?? config2;
+    const labelOf = (col) => {
+      var _a3;
+      return col ? getOpt((_a3 = meta3 == null ? void 0 : meta3.get(col)) == null ? void 0 : _a3.label) ?? col : "";
+    };
+    return { treatment: labelOf(rc == null ? void 0 : rc.treatment), outcome: labelOf(rc == null ? void 0 : rc.outcome), subject: SUBJECT_ONE, subjects: SUBJECT_MANY };
+  }, [ranConfig, config2, meta3]);
   const view = React.useMemo(() => {
-    if (!spec) return null;
-    return deriveView(spec, columns, estimate.result, refute.result, dose.result, journalBind.value, meta3, nRows, now2);
-  }, [spec, columns, estimate.result, refute.result, dose.result, journalBind.value, meta3, nRows, now2]);
-  if (!spec || !view || !view.answer) {
-    const failed = estimate.status === "failed";
-    return /* @__PURE__ */ jsxRuntime.jsx(react.Box, { layerStyle: "frame", p: "6", children: /* @__PURE__ */ jsxRuntime.jsx(react.Text, { className: failed ? void 0 : "elara-skeleton", textStyle: "body.sm", color: "fg.muted", children: failed ? "Could not run the experiment." : "Loading experiment…" }) });
-  }
-  const { spec: vs, answer: a2, refute: vr, dose: vd, journal } = view;
-  const clear = a2.lo > 0 || a2.hi < 0;
-  const ans = a2;
+    if (!config2) return null;
+    return deriveView(config2, ranConfig ?? config2, columns, experiment.result, journalBind.value, meta3, nRows, now2);
+  }, [config2, ranConfig, columns, experiment.result, journalBind.value, meta3, nRows, now2]);
+  const designConfigValue = React.useMemo(() => ({
+    alpha: east.none,
+    target_power: east.none,
+    materiality: east.none,
+    treated_shares: east.some([0.5, 0.3])
+  }), []);
+  const designSnapRef = React.useRef(null);
+  React.useEffect(() => {
+    var _a3;
+    if (tab !== "validate" || !hasDesign || design.pending) return;
+    if (!filteredRows || !config2 || !experiment.result) return;
+    if (((_a3 = designSnapRef.current) == null ? void 0 : _a3.result) === experiment.result) return;
+    designSnapRef.current = { result: experiment.result, config: ranConfig ?? config2 };
+    design.call(filteredRows, ranConfig ?? config2, experiment.result, designConfigValue);
+  }, [tab, hasDesign, filteredRows, config2, ranConfig, experiment.result, design, designConfigValue]);
+  const vmDesign = React.useMemo(
+    () => design.result && designSnapRef.current ? deriveDesign(design.result, designSnapRef.current.result, designSnapRef.current.config, meta3) : null,
+    [design.result, meta3]
+  );
+  const designFresh = design.result !== null && ((_b2 = designSnapRef.current) == null ? void 0 : _b2.result) === experiment.result && !design.pending;
+  if (!config2 || !view) {
+    const failed2 = experiment.status === "failed";
+    return /* @__PURE__ */ jsxRuntime.jsx(react.Box, { layerStyle: "frame", p: "6", children: failed2 && experiment.error ? /* @__PURE__ */ jsxRuntime.jsx(RunError, { error: experiment.error }) : /* @__PURE__ */ jsxRuntime.jsx(react.Text, { className: failed2 ? void 0 : "elara-skeleton", textStyle: "body.sm", color: "fg.muted", children: failed2 ? "Could not run the experiment." : "Loading experiment…" }) });
+  }
+  const { spec: vs, answer: a2, refusal: ref, overlap: ov, refute: vr, dose: vd, journal, verdict } = view;
   const higherBetter = getOpt((_c2 = meta3 == null ? void 0 : meta3.get(vs.outcome)) == null ? void 0 : _c2.higherIsBetter);
-  const dirUp = ans.effect > 0;
-  const statusWord = higherBetter === void 0 ? dirUp ? "Higher" : "Lower" : dirUp === higherBetter ? "Better" : "Worse";
-  const flip = Math.sign(ans.naive) !== Math.sign(ans.effect) && ans.naive !== 0;
-  const top = ans.balance[0] ?? { col: "", display: "" };
-  const lowerWord = ans.naive < 0 ? "lower" : "higher";
-  const population = getOpt(spec.population) ?? [];
   const dataStatus = statusR({ status: "success", size: "sm" });
   const barList = (rows) => /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: bs.root, children: rows.map((r2, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: bs.row, children: [
     /* @__PURE__ */ jsxRuntime.jsx(react.Text, { css: bs.label, textStyle: "mono.sm", color: "fg.default", truncate: true, children: r2.label }),
     /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: bs.track, children: /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: bs.fill, width: `${Math.round(r2.frac * 100)}%`, bg: toneToken(r2.tone) }) }),
     /* @__PURE__ */ jsxRuntime.jsx(react.Text, { css: bs.value, children: r2.value })
   ] }, i)) });
-  const specStaged = specBind.mode === "staged";
+  const specStaged = configBind.mode === "staged";
   const hasJournal = v3.journal.type === "some";
   const canRun = !readonly;
   const canCommit = !readonly && specStaged && hasJournal;
-  const runDisabled = !data4.value || estimate.pending;
-  const commitDisabled = !estimate.result || estimate.pending || stale;
-  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "frame", overflow: "visible", children: [
+  const runDisabled = !data4.value || experiment.pending;
+  const commitDisabled = experiment.status !== "succeeded" || experiment.pending || stale;
+  const failed = experiment.status === "failed" && experiment.error;
+  const showResult = experiment.result !== null && !experiment.pending && !failed;
+  const tabKeys = [...["answer", "trust", "dose"], ...hasDesign ? ["validate"] : []];
+  return /* @__PURE__ */ jsxRuntime.jsx(GuidanceProvider, { on: guidance, vars: helpVars, children: /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "frame", overflow: "visible", children: [
     /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "header.bar", display: "flex", alignItems: "center", gap: "3.5", children: [
-      /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "title.card", children: [
-        "Does ",
-        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "brand.fg", fontWeight: "bold", children: vs.treatment }),
-        " change ",
-        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "brand.fg", fontWeight: "bold", children: vs.outcome }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "title.card", color: "fg.muted", children: /* @__PURE__ */ jsxRuntime.jsxs(Help, { id: "header", children: [
+        "Does ",
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "brand.solid", fontWeight: "bold", children: vs.treatment }),
+        " change ",
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "brand.solid", fontWeight: "bold", children: vs.outcome }),
         "?"
-      ] }),
+      ] }) }),
       /* @__PURE__ */ jsxRuntime.jsx(react.Box, { flex: "1" }),
       /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: dataStatus.root, children: [
         /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: dataStatus.indicator }),
-        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: dataStatus.label, children: vs.dataLabel })
+        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: dataStatus.label, children: stale ? `${nRows} rows` : vs.dataLabel })
       ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(GuidanceToggle, { on: guidance, onToggle: () => setGuidance((g2) => !g2) }),
       canRun && /* @__PURE__ */ jsxRuntime.jsx(ActionButton, { button, variant: "solid", label: "Run", onClick: onRun, disabled: runDisabled, pulse: stale }),
       canCommit && /* @__PURE__ */ jsxRuntime.jsx(ActionButton, { button, variant: "ghost", label: "Commit", onClick: onCommit, disabled: commitDisabled })
     ] }),
     /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "304px minmax(0,1fr)", alignItems: "start", children: [
       /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { borderRightWidth: "1px", borderColor: "border.subtle", children: [
-        /* @__PURE__ */ jsxRuntime.jsxs(Step, { n: 1, title: "What did you change?", children: [
-          /* @__PURE__ */ jsxRuntime.jsx(ColumnPick, { column: vs.treatment, kind: vs.treatmentKind, badge, button, choices: columns.filter((c2) => c2.kind === "boolean" || c2.kind === "integer").map((c2) => c2.name), onPick: (c2) => editSpec({ ...spec, treatment: c2 }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(Step, { n: 1, title: "What did you change?", help: "step_treatment", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ColumnPick, { column: vs.treatment, kind: vs.treatmentKind, badge, button, choices: columns.filter((c2) => c2.kind === "boolean" || c2.kind === "integer").map((c2) => c2.name), onPick: (c2) => editConfig({ ...config2, treatment: c2 }) }),
           /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "caption", mt: "1.5", children: [
             "Treated = ",
             /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.default", fontWeight: "semibold", children: vs.comparison })
           ] })
         ] }),
-        /* @__PURE__ */ jsxRuntime.jsx(Step, { n: 2, title: "What did you want it to improve?", children: /* @__PURE__ */ jsxRuntime.jsx(ColumnPick, { column: vs.outcome, kind: vs.outcomeKind, badge, button, choices: columns.filter((c2) => c2.kind === "float" || c2.kind === "integer").map((c2) => c2.name), onPick: (c2) => editSpec({ ...spec, outcome: c2 }) }) }),
-        /* @__PURE__ */ jsxRuntime.jsx(Step, { n: 3, title: "What else was different about those batches?", children: /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "frame.flat", children: [
-          vs.confounders.map((c2, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "1fr 78px 16px", gap: "2.5", alignItems: "center", px: "2.5", py: "2.5", borderTopWidth: i ? "1px" : "0", borderColor: "border.subtle", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(Step, { n: 2, title: "What did you want it to improve?", help: "step_outcome", children: /* @__PURE__ */ jsxRuntime.jsx(ColumnPick, { column: vs.outcome, kind: vs.outcomeKind, badge, button, choices: columns.filter((c2) => c2.kind === "float" || c2.kind === "integer").map((c2) => c2.name), onPick: (c2) => editConfig({ ...config2, outcome: c2 }) }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(Step, { n: 3, title: "What else was different?", help: "step_confounders", children: /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "frame.flat", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react.Box, { maxH: "216px", overflowY: "auto", children: vs.confounders.map((c2, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "1fr 78px 16px", gap: "2.5", alignItems: "center", px: "2.5", py: "2.5", borderTopWidth: i ? "1px" : "0", borderColor: "border.subtle", children: [
             /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { children: [
               /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono.sm", fontWeight: "semibold", color: "fg.default", children: c2.col }),
               /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption", lineHeight: "1.35", mt: "px", children: c2.reason })
             ] }),
             /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { children: [
               /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: bs.track, children: /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: bs.fill, width: `${Math.round(c2.imbalance * 100)}%`, bg: toneToken(c2.tone) }) }),
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", fontSize: "9px", textAlign: "center", mt: "1.5", children: c2.level })
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", fontSize: "9px", textAlign: "center", mt: "1.5", children: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: "confounder_imbalance", children: c2.level }) })
             ] }),
-            /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "button", css: button({ variant: "ghost", size: "xs" }), px: "0", minW: "16px", display: "inline-flex", alignItems: "center", justifyContent: "center", "aria-label": `Remove ${c2.col}`, onClick: () => editSpec({ ...spec, confounders: spec.confounders.filter((x2) => x2 !== c2.col), categorical: spec.categorical.filter((x2) => x2 !== c2.col) }), children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faXmark, style: { fontSize: "11px" } }) })
-          ] }, i)),
-          vs.suggestion && /* @__PURE__ */ jsxRuntime.jsx(ColumnMenu, { choices: columns.filter((c2) => !(/* @__PURE__ */ new Set([spec.treatment, spec.outcome, ...spec.confounders])).has(c2.name)).map((c2) => c2.name), onPick: (c2) => editSpec({ ...spec, confounders: [...spec.confounders, c2] }), children: /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "button", css: button({ variant: "ghost", size: "sm" }), justifyContent: "flex-start", width: "100%", color: "brand.fg", fontFamily: "mono", display: "inline-flex", alignItems: "center", gap: "2", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "button", css: button({ variant: "ghost", size: "xs" }), px: "0", minW: "16px", display: "inline-flex", alignItems: "center", justifyContent: "center", "aria-label": `Remove ${c2.col}`, onClick: () => editConfig({ ...config2, common_causes: config2.common_causes.filter((x2) => x2 !== c2.col), categorical: config2.categorical.type === "some" ? east.some(config2.categorical.value.filter((x2) => x2 !== c2.col)) : east.none }), children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faXmark, style: { fontSize: "11px" } }) })
+          ] }, i)) }),
+          vs.suggestion && /* @__PURE__ */ jsxRuntime.jsx(ColumnMenu, { choices: columns.filter((c2) => !(/* @__PURE__ */ new Set([config2.treatment, config2.outcome, ...config2.common_causes])).has(c2.name)).map((c2) => c2.name), onPick: (c2) => editConfig({ ...config2, common_causes: [...config2.common_causes, c2] }), children: /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "button", css: button({ variant: "ghost", size: "sm" }), justifyContent: "flex-start", width: "100%", color: "brand.fg", fontFamily: "mono", display: "inline-flex", alignItems: "center", gap: "2", children: [
             /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faPlus, style: { fontSize: "9px" } }),
             "add another"
           ] }) })
         ] }) }),
-        /* @__PURE__ */ jsxRuntime.jsx(Step, { n: 4, title: "Which batches?", children: /* @__PURE__ */ jsxRuntime.jsx(FilterRail, { fields, population, onChange: (next2) => editSpec({ ...spec, population: next2.length ? east.some(next2) : east.none }), chip, button }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(Step, { n: 4, title: `Which ${SUBJECT_MANY}?`, help: "step_population", children: /* @__PURE__ */ jsxRuntime.jsx(FilterRail, { fields, population, onChange: editPopulation, chip, button }) }),
         /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "details", borderTopWidth: "1px", borderColor: "border.subtle", children: [
           /* @__PURE__ */ jsxRuntime.jsxs(
             react.Box,
@@ -59694,173 +60961,168 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
             }
           ),
           /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { px: "4.5", pb: "3.5", pt: "0.5", children: [
-            /* @__PURE__ */ jsxRuntime.jsx(Segmented, { label: "How to compare", left: "regression", right: "reweighting", active: vs.method === "reweighting" ? "right" : "left", onPick: (s2) => editSpec({ ...spec, method: east.some(s2 === "right" ? east.variant("propensity_score_weighting", { weighting_scheme: east.none }) : east.variant("linear_regression", null)) }) }),
-            /* @__PURE__ */ jsxRuntime.jsx(Segmented, { label: "Answer for", left: "all batches", right: "only treated", active: vs.target === "treated" ? "right" : "left", onPick: (s2) => editSpec({ ...spec, targetUnits: east.some(east.variant(s2 === "right" ? "att" : "ate", null)) }) }),
-            /* @__PURE__ */ jsxRuntime.jsx(Segmented, { label: "Drop un-matchable", left: "on", right: "off", active: vs.trim ? "left" : "right", onPick: (s2) => editSpec({ ...spec, trim: s2 === "left" ? east.some(east.variant("overlap", null)) : east.none }), last: true })
+            /* @__PURE__ */ jsxRuntime.jsx(Segmented, { label: "How to compare", help: "adv_method", left: "regression", right: "reweighting", active: vs.method === "reweighting" ? "right" : "left", onPick: (s2) => editConfig({ ...config2, method: east.some(s2 === "right" ? east.variant("propensity_score_weighting", { weighting_scheme: east.none }) : east.variant("linear_regression", null)) }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(Segmented, { label: "Answer for", help: "adv_estimand", left: "all", right: "only treated", active: vs.target === "treated" ? "right" : "left", onPick: (s2) => editConfig({ ...config2, estimand: east.some(east.variant(s2 === "right" ? "att" : "ate", null)) }), last: true })
           ] })
         ] })
       ] }),
       /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { minW: "0", children: [
-        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", px: "4", borderBottomWidth: "1px", borderColor: "border.subtle", children: ["answer", "trust", "dose"].map((tk) => {
-          const on3 = tab === tk;
-          return /* @__PURE__ */ jsxRuntime.jsx(
-            react.Box,
-            {
-              as: "button",
-              onClick: () => setTab(tk),
-              cursor: "pointer",
-              fontSize: "xs",
-              fontWeight: "semibold",
-              px: "3.5",
-              py: "3",
-              mb: "-1px",
-              color: on3 ? "brand.fg" : "fg.muted",
-              borderBottomWidth: "2px",
-              borderColor: on3 ? "brand.solid" : "transparent",
-              _hover: { color: on3 ? "brand.fg" : "fg.default" },
-              children: tk === "answer" ? "Answer" : tk === "trust" ? "Can we trust it?" : "How much?"
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          react.Box,
+          {
+            display: "flex",
+            alignItems: "center",
+            px: "4",
+            borderBottomWidth: "1px",
+            borderColor: "border.subtle",
+            role: "tablist",
+            "aria-label": "Result views",
+            onKeyDown: (e3) => {
+              var _a3;
+              const i = tabKeys.indexOf(tab);
+              let j2 = i;
+              if (e3.key === "ArrowRight") j2 = (i + 1) % tabKeys.length;
+              else if (e3.key === "ArrowLeft") j2 = (i - 1 + tabKeys.length) % tabKeys.length;
+              else if (e3.key === "Home") j2 = 0;
+              else if (e3.key === "End") j2 = tabKeys.length - 1;
+              else return;
+              e3.preventDefault();
+              setTab(tabKeys[j2]);
+              const btns = e3.currentTarget.querySelectorAll('[role="tab"]');
+              (_a3 = btns[j2]) == null ? void 0 : _a3.focus();
             },
-            tk
-          );
-        }) }),
-        tab === "answer" && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
-          /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "4.5", flexWrap: "wrap", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "0.5", children: [
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: ans.outcome }),
-              /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "baseline", gap: "2.5", children: [
-                /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono-kpi", fontFamily: "heading", fontSize: "32px", color: clear ? "fg.success" : "fg.warning", children: signed(ans.effect) }),
-                /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: [
-                  "95% CI  ",
-                  signed(ans.lo),
-                  " … ",
-                  signed(ans.hi)
-                ] })
+            children: [
+              tabKeys.map((tk) => {
+                const on3 = tab === tk;
+                const tabHelp = tk === "answer" ? "tab_answer" : tk === "trust" ? "tab_trust" : tk === "dose" ? "tab_dose" : "tab_validate";
+                const tabLabel = tk === "answer" ? "Answer" : tk === "trust" ? "Trust" : tk === "dose" ? "Dose" : "Validate";
+                return /* @__PURE__ */ jsxRuntime.jsx(
+                  react.Box,
+                  {
+                    as: "button",
+                    role: "tab",
+                    "aria-selected": on3,
+                    tabIndex: on3 ? 0 : -1,
+                    onClick: () => setTab(tk),
+                    cursor: "pointer",
+                    fontSize: "xs",
+                    fontWeight: "semibold",
+                    px: "3.5",
+                    py: "3",
+                    mb: "-1px",
+                    color: on3 ? "brand.fg" : "fg.muted",
+                    borderBottomWidth: "2px",
+                    borderColor: on3 ? "brand.solid" : "transparent",
+                    _hover: { color: on3 ? "brand.fg" : "fg.default" },
+                    _focusVisible: { outline: "2px solid", outlineColor: "brand.solid", outlineOffset: "-2px" },
+                    children: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: tabHelp, children: tabLabel })
+                  },
+                  tk
+                );
+              }),
+              experiment.pending && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { ml: "auto", display: "inline-flex", alignItems: "center", gap: "2", color: "fg.muted", pr: "1", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(react.Spinner, { size: "xs", borderWidth: "1.5px", color: "brand.solid" }),
+                /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", children: "Running…" })
               ] })
-            ] }),
-            /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: badge({ variant: clear ? "ok" : "warn", size: "md" }), alignSelf: "flex-end", mb: "1", display: "inline-flex", alignItems: "center", gap: "1", children: [
-              clear && /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: dirUp ? faArrowUp : faArrowDown, style: { fontSize: "10px" } }),
-              clear ? `${statusWord} with ${ans.treatment}` : "No clear effect"
-            ] })
-          ] }),
-          flip && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "banner.stale", display: "flex", alignItems: "flex-start", gap: "2", mt: "3", children: [
-            /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", color: "fg.warning", flexShrink: "0", mt: "0.5", fontSize: "12px", children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faTriangleExclamation }) }),
+            ]
+          }
+        ),
+        failed ? /* @__PURE__ */ jsxRuntime.jsx(react.Box, { px: "4.5", pt: "4.5", children: /* @__PURE__ */ jsxRuntime.jsx(RunError, { error: experiment.error }) }) : !showResult ? /* @__PURE__ */ jsxRuntime.jsx(DeckSkeleton, { tab }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          stale && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "banner.stale", display: "flex", alignItems: "center", gap: "2", mx: "4.5", mt: "4.5", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", color: "fg.warning", flexShrink: "0", fontSize: "12px", children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faTriangleExclamation }) }),
             /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "body.sm", color: "fg.default", children: [
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "bold", children: "Raw and like-for-like disagree." }),
-              " In the plain average, ",
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", children: ans.treatment }),
-              " batches sit ",
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontStyle: "italic", children: lowerWord }),
-              " on ",
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", children: ans.outcome }),
-              " (",
-              signed(ans.naive),
-              ") — but they also differ most on ",
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", children: top.col }),
-              " (",
-              top.display,
-              "). Adjusting for it reverses the result."
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "bold", children: "Showing the previous setup." }),
+              " Hit Run to update these results for your edits."
             ] })
           ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs(Card, { children: [
-            /* @__PURE__ */ jsxRuntime.jsx(Cap, { children: "Raw average vs. like-for-like" }),
-            /* @__PURE__ */ jsxRuntime.jsx(
-              ForestPlot,
-              {
-                rows: [
-                  { label: "Raw average", note: "unadjusted", est: ans.naive, lo: ans.naiveLo, hi: ans.naiveHi, tone: ans.naive < 0 ? "neg" : "pos" },
-                  { label: "Like-for-like", note: "adjusted", est: ans.effect, lo: ans.lo, hi: ans.hi, tone: clear ? "pos" : "warn" }
-                ],
-                min: Math.floor(Math.min(ans.naiveLo, ans.lo) - 2),
-                max: Math.ceil(Math.max(ans.naiveHi, ans.hi) + 2),
-                unit: `change in ${ans.outcome}${ans.unit ? ` (${ans.unit})` : ""}`,
-                height: 150
-              }
-            )
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs(Card, { children: [
-            /* @__PURE__ */ jsxRuntime.jsx(Cap, { children: "How unbalanced each one was — before adjusting" }),
-            /* @__PURE__ */ jsxRuntime.jsx(react.Box, { py: "0.5", children: barList(ans.balance.map((b2) => ({ label: b2.col, frac: b2.frac, tone: b2.tone, value: b2.display }))) })
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", gap: "4", mt: "3.5", children: [[ans.nTotal, "batches"], [ans.nCompared, "compared like-for-like"], [ans.nDropped, "had no fair match"]].map(([n2, label], i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: [
-            /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.default", fontWeight: "semibold", children: Number(n2) }),
-            " ",
-            label
-          ] }, i)) })
-        ] }),
-        tab === "trust" && vr && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
-          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "body.sm", color: "fg.muted", mb: "3.5", children: "Before trusting the answer we tried to break it — colour shows pass / caution." }),
-          /* @__PURE__ */ jsxRuntime.jsx(react.Box, { layerStyle: "frame.flat", children: vr.checks.map((c2, i) => {
-            const cs = statusR({ status: c2.passed ? "success" : "warning", size: "sm" });
-            return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "auto 1fr minmax(96px,auto)", gap: "2.5", alignItems: "start", px: "3.5", py: "2.5", borderTopWidth: i ? "1px" : "0", borderColor: "border.subtle", children: [
-              /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: cs.root, mt: "1", children: /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: cs.indicator }) }),
-              /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { children: [
-                /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "body.sm", fontWeight: "semibold", color: "fg.default", children: c2.name }),
-                /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption", lineHeight: "1.45", mt: "0.5", children: c2.desc })
-              ] }),
-              /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "inline-flex", alignItems: "center", justifyContent: "flex-end", gap: "1.5", whiteSpace: "nowrap", color: c2.passed ? "fg.success" : "fg.warning", children: [
-                /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono.sm", fontWeight: "bold", fontVariantNumeric: "tabular-nums", children: c2.value }),
-                /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: c2.passed ? faCheck : faTriangleExclamation, style: { fontSize: "11px" } })
-              ] })
-            ] }, i);
-          }) }),
-          /* @__PURE__ */ jsxRuntime.jsxs(Card, { children: [
-            /* @__PURE__ */ jsxRuntime.jsx(Cap, { children: "Effect as a hidden cause is made stronger" }),
-            /* @__PURE__ */ jsxRuntime.jsx(AreaRange, { lo: vr.sensLo, mid: vr.sensMid, hi: vr.sensHi, zero: 0, tone: "brand", xTicks: vr.sensXTicks, yTicks: vr.sensYTicks, height: 132 })
-          ] })
-        ] }),
-        tab === "dose" && vd && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
-          vd.segments.length > 1 && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "2.5", mb: "3.5", children: [
-            /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", children: "Response for" }),
-            /* @__PURE__ */ jsxRuntime.jsx(SegmentSelect, { options: vd.segments, active: 0, onPick: () => {
-            } })
+          tab === "answer" && a2 && /* @__PURE__ */ jsxRuntime.jsx(AnswerNumeric, { a: a2, verdict, higherBetter, badge, barList }),
+          tab === "answer" && !a2 && ref && /* @__PURE__ */ jsxRuntime.jsx(RefusalZone, { refusal: ref, overlap: ov, naiveValue: ((_d2 = experiment.result) == null ? void 0 : _d2.naive) ?? 0, outcome: vs.outcome }),
+          tab === "trust" && vr && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "body.sm", color: "fg.muted", mb: "3.5", children: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: "trust_intro", children: "Before trusting the answer we tried to break it — colour shows pass / caution." }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(react.Box, { layerStyle: "frame.flat", children: vr.checks.map((c2, i) => {
+              const cs = statusR({ status: c2.passed ? "success" : "warning", size: "sm" });
+              return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "auto 1fr minmax(96px,auto)", gap: "2.5", alignItems: "start", px: "3.5", py: "2.5", borderTopWidth: i ? "1px" : "0", borderColor: "border.subtle", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: cs.root, mt: "1", children: /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: cs.indicator }) }),
+                /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "body.sm", fontWeight: "semibold", color: "fg.default", children: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: c2.help, children: c2.name }) }),
+                  /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption", lineHeight: "1.45", mt: "0.5", children: c2.desc })
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "inline-flex", alignItems: "center", justifyContent: "flex-end", gap: "1.5", whiteSpace: "nowrap", color: c2.passed ? "fg.success" : "fg.warning", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono.sm", fontWeight: "bold", fontVariantNumeric: "tabular-nums", children: c2.value }),
+                  /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: c2.passed ? faCheck : faTriangleExclamation, style: { fontSize: "11px" } })
+                ] })
+              ] }, i);
+            }) }),
+            vr.sens && /* @__PURE__ */ jsxRuntime.jsxs(Card, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(Cap, { help: "sensitivity", children: "Effect as a hidden cause is made stronger" }),
+              /* @__PURE__ */ jsxRuntime.jsx(AreaRange, { lo: vr.sens.lo, mid: vr.sens.mid, hi: vr.sens.hi, zero: 0, tone: "brand", xTicks: vr.sens.xTicks, yTicks: vr.sens.yTicks, height: 132 })
+            ] })
           ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs(Card, { mt: "0", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs(Cap, { children: [
-              vd.outcome,
-              " gained vs. ",
-              vd.feature
+          tab === "trust" && !vr && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "inline-flex", alignItems: "center", gap: "2", mb: "2", color: "fg.muted", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faTriangleExclamation, style: { fontSize: "13px" } }),
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "body.sm", fontWeight: "semibold", color: "fg.default", children: "Nothing to stress-test" })
             ] }),
-            /* @__PURE__ */ jsxRuntime.jsx(AreaRange, { lo: vd.lo, mid: vd.mid, hi: vd.hi, tone: "pos", xTicks: vd.xTicks, yTicks: vd.yTicks, marks: vd.marks.map((m2) => ({ at: Number(m2.at), label: m2.label, tone: m2.tone })), height: 256 })
+            /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "body.sm", color: "fg.muted", lineHeight: "1.5", children: [
+              "There’s no adjusted estimate to try to break — the experiment couldn’t produce one (see the ",
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "semibold", color: "fg.default", children: "Answer" }),
+              " tab for why)."
+            ] })
           ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "1fr 1fr", gap: "3", mt: "3", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "card", p: "3.5", borderRadius: "lg", children: [
-              /* @__PURE__ */ jsxRuntime.jsx(Cap, { children: "Recommended" }),
-              /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "0.5", children: [
-                /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", children: vd.recoLabel }),
-                /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "baseline", gap: "2", children: [
-                  /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono-kpi", fontFamily: "heading", color: "brand.solid", children: signed(vd.recoEffect) }),
-                  /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: [
-                    vd.outcome,
-                    " · ",
-                    signed(vd.recoLo),
-                    " … ",
-                    signed(vd.recoHi)
-                  ] })
-                ] })
+          tab === "dose" && vd && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(Card, { mt: "0", children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(Cap, { help: "dose_curve", children: [
+                vd.outcome,
+                " gained vs. ",
+                vd.feature
               ] }),
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption", mt: "2.5", pt: "2.5", borderTopWidth: "1px", borderColor: "border.subtle", children: vd.tradeoff })
+              /* @__PURE__ */ jsxRuntime.jsx(AreaRange, { lo: vd.lo, mid: vd.mid, hi: vd.hi, tone: "pos", xTicks: vd.xTicks, yTicks: vd.yTicks, marks: vd.marks.map((m2) => ({ at: m2.at, label: m2.label, tone: m2.tone, help: m2.help })), height: 256 })
             ] }),
-            /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "card", p: "3.5", borderRadius: "lg", children: [
-              /* @__PURE__ */ jsxRuntime.jsxs(Cap, { children: [
-                "Extra ",
-                vd.outcome,
-                " per step"
+            /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "1fr 1fr", gap: "3", mt: "3", children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "card", p: "3.5", borderRadius: "lg", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(Cap, { help: "dose_reco", children: "Recommended" }),
+                /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "0.5", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", children: vd.recoLabel }),
+                  /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "baseline", gap: "2", children: [
+                    /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono-kpi", fontFamily: "heading", color: "brand.solid", children: signed(vd.recoEffect) }),
+                    /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: [
+                      vd.outcome,
+                      " · ",
+                      signed(vd.recoLo),
+                      " … ",
+                      signed(vd.recoHi)
+                    ] })
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption", mt: "2.5", pt: "2.5", borderTopWidth: "1px", borderColor: "border.subtle", children: vd.tradeoff })
               ] }),
-              /* @__PURE__ */ jsxRuntime.jsx(react.Box, { py: "0.5", children: barList(vd.marginal.map((m2, i) => ({ label: m2.label, frac: m2.frac, tone: i < 2 ? "brand" : "muted", value: signed(m2.value) }))) })
+              /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "card", p: "3.5", borderRadius: "lg", children: [
+                /* @__PURE__ */ jsxRuntime.jsxs(Cap, { help: "dose_marginal", children: [
+                  "Extra ",
+                  vd.outcome,
+                  " per step"
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsx(react.Box, { py: "0.5", maxH: "200px", overflowY: "auto", children: barList(vd.marginal.map((m2, i) => ({ label: m2.label, frac: m2.frac, tone: i < 2 ? "brand" : "muted", value: signed(m2.value) }))) })
+              ] })
             ] })
-          ] })
+          ] }),
+          tab === "validate" && (design.status === "failed" && design.error ? /* @__PURE__ */ jsxRuntime.jsx(react.Box, { px: "4.5", pt: "4.5", children: /* @__PURE__ */ jsxRuntime.jsx(RunError, { error: design.error }) }) : designFresh && vmDesign ? /* @__PURE__ */ jsxRuntime.jsx(ValidatePanel, { vm: vmDesign, barList }) : /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", display: "inline-flex", alignItems: "center", gap: "2", color: "fg.muted", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(react.Spinner, { size: "xs", borderWidth: "1.5px", color: "brand.solid" }),
+            /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "body.sm", children: "Sizing the trial that would confirm this…" })
+          ] }))
         ] })
       ] })
     ] }),
     journal && journal.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
       /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: es.root, bg: "bg.canvas", borderTopWidth: "1px", borderColor: "border.subtle", children: [
-        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: es.lbl, children: "Committed experiments" }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: es.lbl, children: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: "journal", children: "Committed experiments" }) }),
         /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: es.meta, children: [
           /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.default", fontWeight: "semibold", children: journal.length }),
-          " on record"
+          " on record",
+          journal.length > 50 ? " · showing newest 50" : ""
         ] })
       ] }),
-      journal.map((r2, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "2fr 1fr 1fr 1fr", gap: "3", alignItems: "center", px: "4.5", py: "2.5", borderTopWidth: "1px", borderColor: "border.subtle", children: [
+      journal.slice(0, 50).map((r2, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "2fr 1fr 1fr 1fr", gap: "3", alignItems: "center", px: "4.5", py: "2.5", borderTopWidth: "1px", borderColor: "border.subtle", children: [
         /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "body.sm", children: [
           /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { as: "span", fontWeight: "bold", children: [
             r2.treatment,
@@ -59874,7 +61136,7 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
           ] })
         ] }),
         /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono.sm", fontWeight: "semibold", textAlign: "right", fontVariantNumeric: "tabular-nums", color: r2.verdictTone === "pos" ? "fg.success" : "fg.default", children: r2.effect }),
-        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", textAlign: "right", color: r2.verdictTone === "pos" ? "fg.success" : "fg.warning", children: r2.verdict }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", textAlign: "right", color: toneToken(r2.verdictTone), children: r2.verdict }),
         /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "mono.sm", textAlign: "right", color: "fg.muted", children: [
           r2.who,
           " · ",
@@ -59882,8 +61144,187 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
         ] })
       ] }, i))
     ] })
+  ] }) });
+}, (prev2, next2) => experimentValueEqual(prev2.value, next2.value) && prev2.storageKey === next2.storageKey);
+function AnswerNumeric({ a: a2, verdict, higherBetter, badge, barList }) {
+  const dirUp = a2.effect > 0;
+  const statusWord = higherBetter === void 0 ? dirUp ? "Higher" : "Lower" : dirUp === higherBetter ? "Better" : "Worse";
+  const lowerWord = a2.naive < 0 ? "lower" : "higher";
+  const top = a2.balance[0] ?? { col: "", display: "" };
+  const kpiColor = a2.clear && !a2.cautious ? "fg.success" : "fg.warning";
+  const badgeOk = a2.clear && !a2.cautious;
+  const badgeText = a2.cautious ? (verdict == null ? void 0 : verdict.label) ?? "Not trustworthy yet" : a2.clear ? `${statusWord} with ${a2.treatment}` : "No clear effect";
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "4.5", flexWrap: "wrap", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "0.5", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: a2.outcome }),
+        /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "baseline", gap: "2.5", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono-kpi", fontFamily: "heading", fontSize: "32px", color: kpiColor, children: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: "answer_effect", children: signed(a2.effect) }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: /* @__PURE__ */ jsxRuntime.jsxs(Help, { id: "answer_ci", children: [
+            "95% CI  ",
+            signed(a2.lo),
+            " … ",
+            signed(a2.hi)
+          ] }) })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: badge({ variant: badgeOk ? "ok" : "warn", size: "md" }), alignSelf: "flex-end", mb: "1", display: "inline-flex", alignItems: "center", gap: "1", children: [
+        a2.clear && !a2.cautious && /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: dirUp ? faArrowUp : faArrowDown, style: { fontSize: "10px" } }),
+        /* @__PURE__ */ jsxRuntime.jsx(Help, { id: `verdict_${(verdict == null ? void 0 : verdict.tag) ?? "modest"}`, children: badgeText })
+      ] })
+    ] }),
+    a2.cautious && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "banner.stale", display: "flex", alignItems: "flex-start", gap: "2", mt: "3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", color: "fg.warning", flexShrink: "0", mt: "0.5", fontSize: "12px", children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faTriangleExclamation }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "body.sm", color: "fg.default", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(Help, { id: "answer_cautious", children: /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "bold", children: "Treat this as provisional." }) }),
+        " We adjusted and got a number, but a robustness check failed — the estimate may still be driven by something we didn’t adjust for. See ",
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "semibold", children: "Can we trust it?" })
+      ] })
+    ] }),
+    a2.flip && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { layerStyle: "banner.stale", display: "flex", alignItems: "flex-start", gap: "2", mt: "3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", color: "fg.warning", flexShrink: "0", mt: "0.5", fontSize: "12px", children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faTriangleExclamation }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "body.sm", color: "fg.default", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(Help, { id: "answer_flip", children: /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "bold", children: "Raw and like-for-like disagree." }) }),
+        " In the plain average, the ",
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", children: a2.treatment }),
+        " group sits ",
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontStyle: "italic", children: lowerWord }),
+        " on ",
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", children: a2.outcome }),
+        " (",
+        signed(a2.naive),
+        ") — but they also differ most on ",
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", children: top.col }),
+        " (",
+        top.display,
+        "). Adjusting for it reverses the result."
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(Card, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(Cap, { help: "forest_plot", children: "Raw average vs. like-for-like" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ForestPlot,
+        {
+          rows: [
+            { label: "Raw average", note: "unadjusted", est: a2.naive, lo: a2.naiveLo, hi: a2.naiveHi, tone: a2.naive < 0 ? "neg" : "pos" },
+            { label: "Like-for-like", note: "adjusted", est: a2.effect, lo: a2.lo, hi: a2.hi, tone: a2.clear && !a2.cautious ? "pos" : "warn" }
+          ],
+          min: Math.floor(Math.min(0, a2.naiveLo, a2.lo) - 2),
+          max: Math.ceil(Math.max(0, a2.naiveHi, a2.hi) + 2),
+          unit: `change in ${a2.outcome}${a2.unit ? ` (${a2.unit})` : ""}`,
+          height: 150,
+          rowHelp: ["forest_naive", "forest_adjusted"]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(Card, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(Cap, { help: "balance", children: "How unbalanced each one was — before adjusting" }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { py: "0.5", maxH: "208px", overflowY: "auto", children: barList(a2.balance.map((b2) => ({ label: b2.col, frac: b2.frac, tone: b2.tone, value: b2.display }))) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Box, { mt: "3.5", children: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: "counts", display: "inline-flex", gap: "4", children: [[a2.nTotal, SUBJECT_MANY], [a2.nCompared, "compared like-for-like"], [a2.nDropped, "had no fair match"]].map(([n2, label], i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.default", fontWeight: "semibold", children: Number(n2) }),
+      " ",
+      label
+    ] }, i)) }) })
   ] });
-});
+}
+function RefusalZone({ refusal, overlap, naiveValue, outcome }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "inline-flex", alignItems: "center", gap: "2", mb: "2", color: "fg.warning", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faTriangleExclamation, style: { fontSize: "14px" } }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "title.card", color: "fg.default", children: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: refusal.kind === "positivity" ? "refusal_positivity" : "refusal_not_estimable", children: refusal.title }) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "body.sm", color: "fg.muted", mb: "3", lineHeight: "1.5", children: refusal.body }),
+    refusal.kind === "positivity" && overlap && /* @__PURE__ */ jsxRuntime.jsxs(Card, { mt: "1", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(Cap, { help: "overlap_histogram", children: [
+        "Propensity overlap — ",
+        overlap.supportLabel
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(OverlapHistogram, { treated: overlap.treated, control: overlap.control, supportLabel: overlap.supportLabel, positivityOk: overlap.positivityOk, height: 170 })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", gap: "4", mt: "3.5", children: refusal.evidence.map((e3, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.default", fontWeight: "semibold", children: e3.value }),
+      " ",
+      e3.label
+    ] }, i)) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "caption", color: "fg.subtle", mt: "3.5", pt: "3", borderTopWidth: "1px", borderColor: "border.subtle", children: [
+      "Raw average difference in ",
+      outcome,
+      " (context only, not an answer): ",
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", color: "fg.muted", children: signed(naiveValue) })
+    ] })
+  ] });
+}
+function ValidatePanel({ vm, barList }) {
+  const stat = react.useSlotRecipe({ key: "stat" })({ size: "lg" });
+  const meter = react.useSlotRecipe({ key: "segmentedMeter" })({});
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(Cap, { help: "tab_validate", children: vm.headline }),
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "flex-end", gap: "5", flexWrap: "wrap", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: stat.root, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { css: stat.label, children: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: "validate_size", children: vm.holdback ? "to hold back from" : "to run" }) }),
+        vm.faint ? /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "body.sm", fontWeight: "semibold", color: "fg.warning", maxW: "220px", children: "Effect too faint to size — set a materiality threshold to size a trial." }) : /* @__PURE__ */ jsxRuntime.jsx(react.Text, { css: stat.valueText, color: "brand.solid", children: vm.primary.nTotal.toLocaleString() })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: meter.root, flex: "1", minW: "220px", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { css: meter.label, children: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: "validate_split", children: vm.holdback ? "Hold-back split" : "Split" }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: meter.track, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: meter.segment, flex: vm.primary.treatedShare, bg: "brand.solid" }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: meter.segment, flex: 1 - vm.primary.treatedShare, bg: "bg.emphasized" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: meter.keyRow, justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: meter.keyItem, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: meter.keyDot, bg: "brand.solid" }),
+            /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", css: meter.valueText, children: vm.primary.nTreated.toLocaleString() }),
+              " ",
+              vm.holdback ? "treated" : "get it"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: meter.keyItem, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: meter.keyDot, bg: "bg.emphasized" }),
+            /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", css: meter.valueText, children: vm.primary.nControl.toLocaleString() }),
+              " ",
+              vm.holdback ? "held back" : "left alone"
+            ] })
+          ] })
+        ] })
+      ] })
+    ] }),
+    vm.matchOn.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(Card, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(Cap, { help: "validate_match", children: "Match both groups on" }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { py: "0.5", children: barList(vm.matchOn.map((m2) => ({ label: m2.display, frac: m2.frac, tone: m2.tone, value: "" }))) })
+    ] }),
+    vm.curve.mid.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(Card, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(Cap, { help: "validate_power", children: "Chance of detecting it" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        AreaRange,
+        {
+          lo: vm.curve.mid,
+          mid: vm.curve.mid,
+          hi: vm.curve.mid,
+          tone: "brand",
+          xTicks: vm.curve.xTicks,
+          yTicks: ["100", "50", "0"],
+          yFormat: "percent",
+          marks: vm.curve.marks.map((m2) => ({ at: m2.at, label: m2.label, tone: m2.tone, help: m2.help })),
+          height: 170
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "body.sm", color: "fg.default", lineHeight: "1.5", mt: "3.5", children: vm.rationale }),
+    vm.alternates.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", flexDirection: "column", gap: "1.5", mt: "3", pt: "3", borderTopWidth: "1px", borderColor: "border.subtle", children: vm.alternates.map((o2, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "caption", color: "fg.muted", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "semibold", color: "fg.default", children: o2.label }),
+      " · ",
+      o2.nTotal.toLocaleString(),
+      " total (",
+      o2.nTreated.toLocaleString(),
+      " / ",
+      o2.nControl.toLocaleString(),
+      ")"
+    ] }, i)) })
+  ] });
+}
 function FilterRail({ fields, population, onChange: onChange2, chip, button }) {
   const [open, setOpen] = React.useState(null);
   const replaceAt = (i, p2) => onChange2(population.map((f2, j2) => j2 === i ? p2 : f2));
@@ -59934,11 +61375,11 @@ function FilterRail({ fields, population, onChange: onChange2, chip, button }) {
     )
   ] });
 }
-function Step({ n: n2, title, children: children2 }) {
+function Step({ n: n2, title, help, children: children2 }) {
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { px: "4.5", py: "3", borderBottomWidth: "1px", borderColor: "border.subtle", children: [
-    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "baseline", gap: "2", mb: "2", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", fontFamily: "mono", fontSize: "9px", fontWeight: "bold", color: "fg.inverse", bg: "brand.solid", w: "16px", h: "16px", borderRadius: "full", display: "inline-flex", alignItems: "center", justifyContent: "center", flex: "0 0 auto", children: n2 }),
-      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "title.row", children: title })
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "baseline", gap: "2.5", mb: "2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", fontFamily: "mono", fontSize: "11px", fontWeight: "bold", color: "brand.fg", flex: "0 0 auto", lineHeight: "1", children: n2 }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "title.row", children: help ? /* @__PURE__ */ jsxRuntime.jsx(Help, { id: help, children: title }) : title })
     ] }),
     children2
   ] });
@@ -59956,13 +61397,45 @@ function ColumnPick({ column: column2, kind, choices, onPick, badge, button }) {
     /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", display: "inline-flex", color: "fg.muted", fontSize: "10px", children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faChevronDown }) })
   ] }) });
 }
-function SegmentSelect({ options: options2, active, onPick, fill, size: size3 = "sm" }) {
+function SegmentSelect({ options: options2, active, onPick, fill, size: size3 = "xs" }) {
   const s2 = react.useSlotRecipe({ key: "segmentGroup" })({ size: size3 });
-  return /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: s2.root, ...fill ? { width: "100%" } : {}, children: options2.map((o2, i) => /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "button", css: s2.item, ...fill ? { flex: "1" } : {}, ...active === i ? { "data-state": "checked" } : {}, onClick: () => onPick(i), children: /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: s2.itemText, children: o2 }) }, i)) });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    react.Box,
+    {
+      css: s2.root,
+      ...fill ? { width: "100%" } : {},
+      role: "radiogroup",
+      onKeyDown: (e3) => {
+        var _a2;
+        const d2 = e3.key === "ArrowRight" || e3.key === "ArrowDown" ? 1 : e3.key === "ArrowLeft" || e3.key === "ArrowUp" ? -1 : 0;
+        if (!d2) return;
+        e3.preventDefault();
+        const next2 = (active + d2 + options2.length) % options2.length;
+        onPick(next2);
+        const btns = e3.currentTarget.querySelectorAll('[role="radio"]');
+        (_a2 = btns[next2]) == null ? void 0 : _a2.focus();
+      },
+      children: options2.map((o2, i) => /* @__PURE__ */ jsxRuntime.jsx(
+        react.Box,
+        {
+          as: "button",
+          role: "radio",
+          "aria-checked": active === i,
+          tabIndex: active === i ? 0 : -1,
+          css: s2.item,
+          ...fill ? { flex: "1" } : {},
+          ...active === i ? { "data-state": "checked" } : {},
+          onClick: () => onPick(i),
+          children: /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: s2.itemText, children: o2 })
+        },
+        i
+      ))
+    }
+  );
 }
-function Segmented({ label, left, right, active, onPick, last: last2 }) {
+function Segmented({ label, left, right, active, onPick, last: last2, help }) {
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", alignItems: "stretch", gap: "1.5", py: "2", borderBottomWidth: last2 ? "0" : "1px", borderColor: "border.subtle", children: [
-    /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", textTransform: "none", letterSpacing: "normal", color: "fg.default", children: label }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", textTransform: "none", letterSpacing: "normal", color: "fg.default", children: help ? /* @__PURE__ */ jsxRuntime.jsx(Help, { id: help, children: label }) : label }),
     /* @__PURE__ */ jsxRuntime.jsx(SegmentSelect, { options: [left, right], active: active === "left" ? 0 : 1, onPick: (i) => onPick(i === 0 ? "left" : "right"), fill: true, size: "xs" })
   ] });
 }
@@ -61664,10 +63137,10 @@ function formatPrimitive(type, value) {
     case "Integer":
       return String(value);
     case "Float": {
-      const num = value;
-      if (Number.isNaN(num)) return "NaN";
-      if (!Number.isFinite(num)) return num > 0 ? "Infinity" : "-Infinity";
-      return String(num);
+      const num2 = value;
+      if (Number.isNaN(num2)) return "NaN";
+      if (!Number.isFinite(num2)) return num2 > 0 ? "Infinity" : "-Infinity";
+      return String(num2);
     }
     case "String":
       return `"${value}"`;
@@ -62105,7 +63578,7 @@ const UITaskPreview = React.memo(function UITaskPreview2({
   const manifest = React.useMemo(() => {
     if (!details || !isUI) return null;
     const meta3 = getTaskMetadata(details);
-    return meta3 ? internal.decodeManifest(meta3) : { paths: [], functions: [] };
+    return meta3 ? internal.decodeManifest(meta3) : { paths: [], functions: [], records: [] };
   }, [details, isUI]);
   const outputPath = details ? treePathToString$1(details.output) : null;
   const preloads = React.useMemo(
@@ -62118,6 +63591,7 @@ const UITaskPreview = React.memo(function UITaskPreview2({
       ...eastUiComponents.StateImpl,
       ...createScopedBindPlatform(manifest),
       ...createScopedFuncPlatform(manifest.functions),
+      ...createScopedRecordPlatform(manifest.records),
       ...eastUiComponents.OverlayImpl
     ] : void 0,
     [manifest]
@@ -62715,6 +64189,8 @@ exports.MemoryStagedAdapter = MemoryStagedAdapter;
 exports.ReactiveDatasetCache = ReactiveDatasetCache;
 exports.ReactiveDatasetLoader = ReactiveDatasetLoader;
 exports.ReactiveDatasetProvider = ReactiveDatasetProvider;
+exports.RecordPlatform = RecordPlatform;
+exports.RecordRuntime = RecordRuntime;
 exports.StagedStore = StagedStore;
 exports.StatusDisplay = StatusDisplay;
 exports.TaskPreview = TaskPreview;
@@ -62726,17 +64202,22 @@ exports.clearFunctionApi = clearFunctionApi;
 exports.clearPendingWrites = clearPendingWrites;
 exports.clearReactiveDatasetCache = clearReactiveDatasetCache;
 exports.clearReactiveDatasetListCache = clearReactiveDatasetListCache;
+exports.clearRecordApi = clearRecordApi;
 exports.clearStagedStoreSingleton = clearStagedStoreSingleton;
 exports.createDefaultDatasetApi = createDefaultDatasetApi;
 exports.createDefaultFunctionApi = createDefaultFunctionApi;
+exports.createDefaultRecordApi = createDefaultRecordApi;
 exports.createInMemoryFunctionApi = createInMemoryFunctionApi;
+exports.createInMemoryRecordApi = createInMemoryRecordApi;
 exports.createReactiveDatasetCache = createReactiveDatasetCache;
 exports.createScopedBindPlatform = createScopedBindPlatform;
 exports.createScopedFuncPlatform = createScopedFuncPlatform;
+exports.createScopedRecordPlatform = createScopedRecordPlatform;
 exports.datasetCacheKey = datasetCacheKey;
 exports.datasetPathToString = datasetPathToString;
 exports.defaultBindRuntime = defaultBindRuntime;
 exports.defaultFuncRuntime = defaultFuncRuntime;
+exports.defaultRecordRuntime = defaultRecordRuntime;
 exports.disableBindingTracking = disableBindingTracking;
 exports.enableBindingTracking = enableBindingTracking;
 exports.formatApiError = formatApiError;
@@ -62749,12 +64230,14 @@ exports.getTaskKind = getTaskKind;
 exports.getTaskMetadata = getTaskMetadata;
 exports.initializeFunctionApi = initializeFunctionApi;
 exports.initializeReactiveDatasetCache = initializeReactiveDatasetCache;
+exports.initializeRecordApi = initializeRecordApi;
 exports.initializeStagedStore = initializeStagedStore;
 exports.isBindingTracking = isBindingTracking;
 exports.onWriteError = onWriteError;
 exports.preloadReactiveDatasetList = preloadReactiveDatasetList;
 exports.realClock = realClock;
-exports.signatureOfHandleType = signatureOfHandleType;
+exports.recordChannelKey = recordChannelKey;
+exports.signatureOfFuncHandleType = signatureOfFuncHandleType;
 exports.trackDatasetPath = trackDatasetPath;
 exports.useDataflowCancel = useDataflowCancel;
 exports.useDataflowExecute = useDataflowExecute;