@elaraai/e3-ui-components 1.0.79 → 1.0.81

package/dist/index.cjs

@@ -2077,6 +2077,7 @@ const realClock = {
     return { clear: () => clearInterval(id3) };
   }
 };
+const HASH_POLL_MS = 1e3;
 function createDefaultDatasetApi(apiUrl, repo, getToken) {
   const opts = () => ({ token: getToken() });
   return {
@@ -2142,12 +2143,17 @@ class ReactiveDatasetCache {
     __publicField(this, "keyVersions", /* @__PURE__ */ new Map());
     // Workspace status polling — groups subscriptions by workspace for
     // efficiency. Each entry holds the active interval handle from the
-    // injected {@link Clock} so tests can drive ticking deterministically.
+    // injected {@link Clock} so tests can drive ticking deterministically,
+    // and each polled path with how many watchers poll it.
     __publicField(this, "workspacePollers", /* @__PURE__ */ new Map());
     __publicField(this, "clock");
     // In-flight poll dedup — concurrent callers (interval tick + a
     // post-write trigger) share a single round-trip rather than racing.
     __publicField(this, "inFlightPolls", /* @__PURE__ */ new Map());
+    // Hash-only watches, by workspace and path: each callback with the hash it
+    // was last told. A watched path rides its workspace's poll, but its
+    // content is never fetched — a paged source reads windows, never the value.
+    __publicField(this, "hashWatches", /* @__PURE__ */ new Map());
     // Batching
     __publicField(this, "batchDepth", 0);
     __publicField(this, "changedKeys", /* @__PURE__ */ new Set());
@@ -2236,9 +2242,7 @@ class ReactiveDatasetCache {
           hash: void 0,
           status: east.variant("stale", null)
         });
-        if (this.workspacePollers.has(workspace)) {
-          void this.pollWorkspaceStatus(workspace);
-        }
+        void this.refresh(workspace);
       } catch (error3) {
         if (!this.destroyed && this.writeEpochs.get(key) === myEpoch) {
           const baseline = this.writeBaselines.get(key);
@@ -2344,15 +2348,15 @@ class ReactiveDatasetCache {
    * 3. Only fetches full content when hash changes
    *
    * Multiple subscriptions to the same workspace share a single poller.
-   * Pair with {@link clearRefetchInterval} on unmount so the poller can
-   * stop when nothing is watching.
+   * Pair each call with one {@link clearRefetchInterval} on unmount so the
+   * poller can stop when nothing is watching.
    */
   setRefetchInterval(workspace, path2, intervalMs) {
     var _a2;
     const pathStr = datasetPathToString(path2);
     let poller = this.workspacePollers.get(workspace);
     if (poller) {
-      poller.paths.add(pathStr);
+      poller.paths.set(pathStr, (poller.paths.get(pathStr) ?? 0) + 1);
       if (intervalMs < poller.intervalMs) {
         (_a2 = poller.handle) == null ? void 0 : _a2.clear();
         poller.intervalMs = intervalMs;
@@ -2364,7 +2368,7 @@ class ReactiveDatasetCache {
     } else {
       poller = {
         intervalMs,
-        paths: /* @__PURE__ */ new Set([pathStr]),
+        paths: /* @__PURE__ */ new Map([[pathStr, 1]]),
         handle: this.clock.setInterval(
           () => this.pollWorkspaceStatus(workspace),
           intervalMs
@@ -2375,23 +2379,79 @@ class ReactiveDatasetCache {
     }
   }
   /**
-   * Stop polling a dataset; the workspace poller is torn down when its
-   * last watched path is cleared.
+   * Stop polling a dataset for one watcher; the path goes when its last
+   * watcher clears it, and the workspace poller is torn down when its last
+   * path goes.
    */
   clearRefetchInterval(workspace, path2) {
-    var _a2;
     const poller = this.workspacePollers.get(workspace);
     if (!poller) return;
-    poller.paths.delete(datasetPathToString(path2));
-    if (poller.paths.size === 0) {
+    const pathStr = datasetPathToString(path2);
+    const watchers = (poller.paths.get(pathStr) ?? 0) - 1;
+    if (watchers > 0) {
+      poller.paths.set(pathStr, watchers);
+      return;
+    }
+    poller.paths.delete(pathStr);
+    this.stopIdlePoller(workspace);
+  }
+  /**
+   * Follow a dataset's content hash without fetching its content; see the
+   * interface doc.
+   */
+  watchHash(workspace, path2, onHash, intervalMs = HASH_POLL_MS) {
+    var _a2;
+    const pathStr = datasetPathToString(path2);
+    let byPath = this.hashWatches.get(workspace);
+    if (!byPath) {
+      byPath = /* @__PURE__ */ new Map();
+      this.hashWatches.set(workspace, byPath);
+    }
+    let callbacks = byPath.get(pathStr);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Map();
+      byPath.set(pathStr, callbacks);
+    }
+    callbacks.set(onHash, void 0);
+    const poller = this.workspacePollers.get(workspace);
+    if (!poller) {
+      this.workspacePollers.set(workspace, {
+        intervalMs,
+        paths: /* @__PURE__ */ new Map(),
+        handle: this.clock.setInterval(() => this.pollWorkspaceStatus(workspace), intervalMs)
+      });
+      void this.pollWorkspaceStatus(workspace);
+    } else if (intervalMs < poller.intervalMs) {
       (_a2 = poller.handle) == null ? void 0 : _a2.clear();
-      this.workspacePollers.delete(workspace);
+      poller.intervalMs = intervalMs;
+      poller.handle = this.clock.setInterval(() => this.pollWorkspaceStatus(workspace), intervalMs);
     }
+    return () => {
+      const watched = this.hashWatches.get(workspace);
+      const set3 = watched == null ? void 0 : watched.get(pathStr);
+      if (!watched || !set3) return;
+      set3.delete(onHash);
+      if (set3.size === 0) watched.delete(pathStr);
+      if (watched.size === 0) this.hashWatches.delete(workspace);
+      this.stopIdlePoller(workspace);
+    };
+  }
+  /** Stops a workspace's poller once it has no path to reconcile and no hash
+   *  to follow — without this, a long-lived session polls forever. */
+  stopIdlePoller(workspace) {
+    var _a2;
+    const poller = this.workspacePollers.get(workspace);
+    if (!poller || poller.paths.size > 0 || this.hashWatches.has(workspace)) return;
+    (_a2 = poller.handle) == null ? void 0 : _a2.clear();
+    this.workspacePollers.delete(workspace);
   }
   refresh(workspace) {
     if (this.destroyed) return Promise.resolve();
     if (!this.workspacePollers.has(workspace)) return Promise.resolve();
-    return this.pollWorkspaceStatus(workspace);
+    const inFlight = this.inFlightPolls.get(workspace);
+    if (inFlight === void 0) return this.pollWorkspaceStatus(workspace);
+    const again = () => this.destroyed || !this.workspacePollers.has(workspace) ? void 0 : this.pollWorkspaceStatus(workspace);
+    return inFlight.then(again, again);
   }
   /**
    * Poll workspace status and reconcile the cache with the server.
@@ -2407,11 +2467,12 @@ class ReactiveDatasetCache {
     return promise4;
   }
   async doPollWorkspaceStatus(workspace) {
+    var _a2;
     if (this.destroyed) return;
     const poller = this.workspacePollers.get(workspace);
-    if (!poller || poller.paths.size === 0) return;
+    if (!poller || poller.paths.size === 0 && !this.hashWatches.has(workspace)) return;
     const epochsAtStart = /* @__PURE__ */ new Map();
-    for (const pathStr of poller.paths) {
+    for (const pathStr of poller.paths.keys()) {
       const key = pathStr ? `${workspace}.${pathStr}` : workspace;
       epochsAtStart.set(key, this.writeEpochs.get(key) ?? 0);
     }
@@ -2425,15 +2486,28 @@ class ReactiveDatasetCache {
     if (this.destroyed) return;
     const infoByPath = /* @__PURE__ */ new Map();
     for (const info of status.datasets) infoByPath.set(info.path, info);
+    for (const [pathStr, callbacks] of this.hashWatches.get(workspace) ?? []) {
+      const info = infoByPath.get(pathStr ? `.${pathStr}` : "");
+      const hash2 = ((_a2 = info == null ? void 0 : info.hash) == null ? void 0 : _a2.type) === "some" ? info.hash.value : null;
+      for (const [onHash, told] of [...callbacks]) {
+        if (told === hash2 || !callbacks.has(onHash)) continue;
+        callbacks.set(onHash, hash2);
+        try {
+          onHash(hash2);
+        } catch (error3) {
+          console.error(`A hash watch on ${workspace}.${pathStr} failed:`, error3);
+        }
+      }
+    }
     const pending = [];
     this.batch(() => {
-      var _a2;
-      for (const pathStr of poller.paths) {
+      var _a3;
+      for (const pathStr of poller.paths.keys()) {
         const e3Path = pathStr ? `.${pathStr}` : "";
         const info = infoByPath.get(e3Path);
         const key = pathStr ? `${workspace}.${pathStr}` : workspace;
         const path2 = this.stringToPath(pathStr);
-        const currentHash = ((_a2 = info == null ? void 0 : info.hash) == null ? void 0 : _a2.type) === "some" ? info.hash.value : null;
+        const currentHash = ((_a3 = info == null ? void 0 : info.hash) == null ? void 0 : _a3.type) === "some" ? info.hash.value : null;
         const knownHash = this.knownHashes.get(key);
         if (info == null ? void 0 : info.status) {
           const previous = this.statuses.get(key);
@@ -2599,6 +2673,7 @@ class ReactiveDatasetCache {
     }
     this.workspacePollers.clear();
     this.inFlightPolls.clear();
+    this.hashWatches.clear();
     this.keySubscribers.clear();
     this.globalSubscribers.clear();
     this.knownHashes.clear();
@@ -2713,9 +2788,16 @@ class MemoryStagedAdapter {
     this.map.clear();
   }
 }
+const SCOPE_SEPARATOR = "\0";
+function cacheKeyOf(key) {
+  return key.slice(key.indexOf(SCOPE_SEPARATOR) + 1);
+}
 class StagedStore {
   constructor(adapter) {
+    // By scope and `datasetCacheKey`; subscribers and versions go by the
+    // `datasetCacheKey` alone, which is what a reactive view tracks.
     __publicField(this, "entries", /* @__PURE__ */ new Map());
+    __publicField(this, "scope", null);
     __publicField(this, "subscribers", /* @__PURE__ */ new Map());
     __publicField(this, "versions", /* @__PURE__ */ new Map());
     __publicField(this, "adapter");
@@ -2739,25 +2821,25 @@ class StagedStore {
     }
   }
   hasPending(workspace, path2) {
-    return this.entries.has(datasetCacheKey(workspace, path2));
+    return this.entries.has(this.keyOf(workspace, path2));
   }
   getBuffered(workspace, path2) {
     var _a2;
-    return (_a2 = this.entries.get(datasetCacheKey(workspace, path2))) == null ? void 0 : _a2.buffered;
+    return (_a2 = this.entries.get(this.keyOf(workspace, path2))) == null ? void 0 : _a2.buffered;
   }
   getSnapshot(workspace, path2) {
     var _a2;
-    return (_a2 = this.entries.get(datasetCacheKey(workspace, path2))) == null ? void 0 : _a2.snapshot;
+    return (_a2 = this.entries.get(this.keyOf(workspace, path2))) == null ? void 0 : _a2.snapshot;
   }
   getEntry(workspace, path2) {
-    return this.entries.get(datasetCacheKey(workspace, path2));
+    return this.entries.get(this.keyOf(workspace, path2));
   }
   write(workspace, path2, snapshotIfNew, buffered) {
-    const key = datasetCacheKey(workspace, path2);
+    const key = this.keyOf(workspace, path2);
     const existing = this.entries.get(key);
     const next2 = existing ? { snapshot: existing.snapshot, buffered } : { snapshot: snapshotIfNew, buffered };
     this.entries.set(key, next2);
-    this.notify(key);
+    this.notify(datasetCacheKey(workspace, path2));
     const persisted = {
       snapshot: next2.snapshot,
       buffered: next2.buffered
@@ -2765,15 +2847,26 @@ class StagedStore {
     this.persist(key, () => this.adapter.save(key, persisted));
   }
   discard(workspace, path2) {
-    const key = datasetCacheKey(workspace, path2);
+    const key = this.keyOf(workspace, path2);
     if (!this.entries.has(key)) return false;
     this.entries.delete(key);
-    this.notify(key);
+    this.notify(datasetCacheKey(workspace, path2));
     this.persist(key, () => this.adapter.remove(key));
     return true;
   }
   listKeys() {
-    return [...this.entries.keys()];
+    const prefix2 = `${this.scope ?? ""}${SCOPE_SEPARATOR}`;
+    return [...this.entries.keys()].filter((key) => key.startsWith(prefix2)).map(cacheKeyOf);
+  }
+  setScope(scope) {
+    const before = this.scope;
+    this.scope = scope;
+    this.notifyScopes(before, scope);
+    return () => {
+      if (this.scope !== scope) return;
+      this.scope = null;
+      this.notifyScopes(scope, null);
+    };
   }
   subscribe(key, callback) {
     let set3 = this.subscribers.get(key);
@@ -2796,15 +2889,29 @@ class StagedStore {
       this.errorListeners.delete(cb);
     };
   }
-  /** Test-only: clear in-memory + persisted state. */
+  /** Test-only: clear in-memory + persisted state, in every scope. */
   async clear() {
     const keys = [...this.entries.keys()];
     this.entries.clear();
-    for (const key of keys) this.notify(key);
+    for (const key of new Set(keys.map(cacheKeyOf))) this.notify(key);
     await this.flushPending();
     await this.adapter.clear();
   }
   // ----- internals -------------------------------------------------------
+  /** The key a path's entry is held under in the current scope. */
+  keyOf(workspace, path2) {
+    return `${this.scope ?? ""}${SCOPE_SEPARATOR}${datasetCacheKey(workspace, path2)}`;
+  }
+  /** Tells every path with an entry in either scope that what it reads has
+   *  changed: the scope's move shows one's entries and hides the other's. */
+  notifyScopes(from2, to) {
+    const keys = /* @__PURE__ */ new Set();
+    for (const key of this.entries.keys()) {
+      const scope = key.slice(0, key.indexOf(SCOPE_SEPARATOR));
+      if (scope === (from2 ?? "") || scope === (to ?? "")) keys.add(cacheKeyOf(key));
+    }
+    for (const key of keys) this.notify(key);
+  }
   notify(key) {
     this.versions.set(key, (this.versions.get(key) ?? 0) + 1);
     const subs = this.subscribers.get(key);
@@ -2821,7 +2928,7 @@ class StagedStore {
     const settled = prev2.then(op, op).then(
       () => void 0,
       (err) => {
-        this.emitPersistError(key, err);
+        this.emitPersistError(cacheKeyOf(key), err);
       }
     ).then(() => {
       if (this.saveChains.get(key) === settled) this.saveChains.delete(key);
@@ -2852,11 +2959,18 @@ class StagedStore {
       return;
     }
     for (const [key, p2] of persisted) {
+      if (!key.includes(SCOPE_SEPARATOR)) {
+        this.persist(key, () => this.adapter.remove(key));
+        this.emitPersistError(key, new Error(
+          `a staged edit of ${key} that an older build left names no server or repository, and was dropped`
+        ));
+        continue;
+      }
       this.entries.set(key, {
         snapshot: p2.snapshot,
         buffered: p2.buffered
       });
-      this.notify(key);
+      this.notify(cacheKeyOf(key));
     }
   }
 }
@@ -2884,7 +2998,7 @@ function clearStagedStoreSingleton() {
 }
 const UNCHANGED_VARIANT = east.variant("unchanged", null);
 const blobEqual = east.equalFor(east.BlobType);
-const eastTypeEqual$2 = east.equalFor(internal.EastTypeType);
+const eastTypeEqual$1 = east.equalFor(internal.EastTypeType);
 const helpersCache = new east.SortedMap(
   void 0,
   east.compareFor(internal.EastTypeType)
@@ -2973,8 +3087,14 @@ class BindRuntime {
     }
     this.cache = cache3;
   }
-  /** Clear the active cache and drop any queued writes. */
-  clearCache() {
+  /**
+   * Clear the active cache and drop any queued writes.
+   *
+   * @param cache - Clear only while this is the active cache, so a provider
+   *   tearing down after another installed its own leaves that one in place
+   */
+  clearCache(cache3) {
+    if (cache3 !== void 0 && this.cache !== cache3) return;
     this.cache = null;
     this.clearPendingWrites();
     this.handleCache.clear();
@@ -3087,11 +3207,11 @@ class BindRuntime {
     const key = datasetCacheKey(workspace, sourcePath);
     const existing = this.bindingRegistry.get(key);
     if (existing) {
-      if (existing.mode === info.mode && existing.hasPatchDataset === info.hasPatchDataset && existing.sourceType === info.sourceType) {
+      if (existing.mode === info.mode && existing.hasPatchDataset === info.hasPatchDataset && Object.is(existing.sourceType, info.sourceType)) {
         return;
       }
       const shapeChanged = existing.mode !== info.mode || existing.hasPatchDataset !== info.hasPatchDataset;
-      const typeChanged = !eastTypeEqual$2(existing.sourceType, info.sourceType);
+      const typeChanged = !eastTypeEqual$1(existing.sourceType, info.sourceType);
       if (!shapeChanged && !typeChanged) {
         this.bindingRegistry.set(key, info);
         return;
@@ -3281,7 +3401,7 @@ class BindRuntime {
     };
     const bindingDescriptor = {
       source: sourcePath,
-      patch: patchPath ? east.variant("some", patchPath) : east.variant("none", null),
+      patch: patchPath ? east.some(patchPath) : east.none,
       mode: east.variant(mode, null)
     };
     const writeStaged = (value) => {
@@ -3299,6 +3419,10 @@ class BindRuntime {
       this.queueWrite(() => cache3.launchDataflow(ws));
       return null;
     };
+    const hasSource = () => {
+      this.trackPath(ws, sourcePath);
+      return cache3.has(ws, sourcePath);
+    };
     if (mode === "direct" && !patchPath) {
       return {
         read: () => {
@@ -3321,7 +3445,7 @@ class BindRuntime {
         pending: () => false,
         commit: () => null,
         discard: () => null,
-        has: () => cache3.has(ws, sourcePath),
+        has: hasSource,
         status: () => {
           this.trackPath(ws, sourcePath);
           return cache3.getStatus(ws, sourcePath);
@@ -3370,7 +3494,7 @@ class BindRuntime {
           this.queueWrite(() => cache3.write(ws, pPath2, encodePatch(UNCHANGED_VARIANT)));
           return null;
         },
-        has: () => cache3.has(ws, sourcePath),
+        has: hasSource,
         status: () => {
           this.trackPath(ws, sourcePath);
           return cache3.getStatus(ws, sourcePath);
@@ -3414,7 +3538,7 @@ class BindRuntime {
           staged.discard(ws, sourcePath);
           return null;
         },
-        has: () => cache3.has(ws, sourcePath),
+        has: hasSource,
         status: () => {
           this.trackPath(ws, sourcePath);
           return cache3.getStatus(ws, sourcePath);
@@ -3461,7 +3585,7 @@ class BindRuntime {
         staged.discard(ws, sourcePath);
         return null;
       },
-      has: () => cache3.has(ws, sourcePath),
+      has: hasSource,
       status: () => {
         this.trackPath(ws, sourcePath);
         return cache3.getStatus(ws, sourcePath);
@@ -3519,8 +3643,8 @@ function getReactiveDatasetCache() {
 function initializeReactiveDatasetCache(cache3) {
   defaultBindRuntime.initializeCache(cache3);
 }
-function clearReactiveDatasetCache() {
-  defaultBindRuntime.clearCache();
+function clearReactiveDatasetCache(cache3) {
+  defaultBindRuntime.clearCache(cache3);
 }
 function enableBindingTracking() {
   return defaultBindRuntime.enableTracking();
@@ -3700,7 +3824,11 @@ class TrackedChannelStore {
     this.keyVersions.clear();
   }
 }
-function createDefaultPagedApi(apiUrl, repo, getToken) {
+const NO_INDEX = { index: null, join: false };
+function selectorKey(selector2) {
+  return selector2.index === null ? "" : `@${selector2.index}${selector2.join ? "+join" : ""}`;
+}
+function createDefaultPagedApi(apiUrl, repo, getToken, datasets) {
   const opts = () => ({ token: getToken() });
   return {
     async getPage(workspace, path2, window3) {
@@ -3708,58 +3836,115 @@ function createDefaultPagedApi(apiUrl, repo, getToken) {
     },
     async findKey(workspace, path2, query) {
       return e3ApiClient.datasetFindKey(apiUrl, repo, workspace, path2, query, opts());
+    },
+    async getRevision(workspace, path2) {
+      const status = await e3ApiClient.datasetGetStatus(apiUrl, repo, workspace, path2, opts());
+      return status.hash.type === "some" ? status.hash.value : null;
+    },
+    watchRevision(workspace, path2, onChange2) {
+      return datasets.watchHash(workspace, path2, onChange2);
     }
   };
 }
 const RETRY_AFTER_MS = 2e3;
 const MAX_RETAINED_WINDOWS = 24;
-const PERMANENT_PAGE_ERRORS = /* @__PURE__ */ new Set(["dataset_not_pageable"]);
-function isPermanentPageError(err) {
+const PERMANENT_PAGE_ERRORS = /* @__PURE__ */ new Set([
+  "bad_request",
+  "dataset_not_canonical",
+  "dataset_not_indexed",
+  "dataset_not_pageable",
+  "dataset_not_searchable",
+  "dataset_not_segmented",
+  "index_not_found",
+  "key_parse_error"
+]);
+const NO_VALUE_ERRORS = /* @__PURE__ */ new Set(["dataset_unassigned", "dataset_null"]);
+function toSelector(indexArg, joinArg) {
+  const index2 = indexArg;
+  return {
+    index: index2 !== void 0 && index2.type === "some" ? index2.value : null,
+    join: joinArg === true
+  };
+}
+function checkDeclared(allowed, path2) {
+  if (allowed === null) return;
+  const pathStr = datasetPathToString(path2);
+  if (!allowed.has(pathStr)) {
+    throw new Error(
+      `Data.bindPaged: source path "${pathStr}" not declared in manifest — bind it in the task body so derivation records it`
+    );
+  }
+}
+function errorCode(err) {
   const code = err == null ? void 0 : err.code;
-  return typeof code === "string" && PERMANENT_PAGE_ERRORS.has(code);
+  return typeof code === "string" ? code : void 0;
+}
+function isPermanentPageError(err) {
+  const code = errorCode(err);
+  return code !== void 0 && PERMANENT_PAGE_ERRORS.has(code);
+}
+function failureOf(path2, err) {
+  const code = errorCode(err);
+  const details = err == null ? void 0 : err.details;
+  const reason = code === void 0 ? err instanceof Error ? err.message : String(err) : typeof details === "string" && details !== "" ? `${code}: ${details}` : code;
+  return `Data.bindPaged: ${datasetPathToString(path2)}: ${reason}`;
 }
 function keyTypeOf(sourceType) {
   if (sourceType.type === "Dict") return sourceType.value.key;
   if (sourceType.type === "Set") return sourceType.value;
   return null;
 }
-function buildSeek(sourceType, T2, pathExpr, platform2) {
-  if (keyTypeOf(sourceType) === null) return east.none;
+function buildSeek(sourceType, T2, pathExpr, indexExpr, joinExpr, selector2, platform2) {
+  if (selector2.index === null && keyTypeOf(sourceType) === null) return east.none;
   const { seek } = internal$1.DataPagedPrimitives;
   return east.some(east.East.compile(
     east.East.function([eastUi.SeekQueryType], east.OptionType(eastUi.SeekRangeType), ($3, query) => {
-      $3.return(seek([T2], pathExpr, query));
+      $3.return(seek([T2], pathExpr, indexExpr, joinExpr, query));
     }),
     platform2
   ));
 }
-function pagedWindowKey(workspace, path2, offset, limit2) {
-  return `paged:${workspace}:${datasetPathToString(path2)}#${offset}+${limit2}`;
+function pagedRevisionKey(workspace, path2) {
+  return `paged:${workspace}:${datasetPathToString(path2)}#revision`;
+}
+function pagedWindowKey(workspace, path2, revision, offset, limit2, selector2 = NO_INDEX) {
+  return `paged:${workspace}:${datasetPathToString(path2)}${selectorKey(selector2)}@${revision}#${offset}+${limit2}`;
 }
-function pagedTotalKey(workspace, path2) {
-  return `paged:${workspace}:${datasetPathToString(path2)}#total`;
+function pagedTotalKey(workspace, path2, revision, selector2 = NO_INDEX) {
+  return `paged:${workspace}:${datasetPathToString(path2)}${selectorKey(selector2)}@${revision}#total`;
 }
-function pagedSeekKey(workspace, path2, query) {
-  const q = "key" in query ? `k=${query.key}` : "fields" in query ? `f=${query.fields.join("\0")}|p=${query.prefix ?? ""}` : `p=${query.prefix}`;
-  return `paged:${workspace}:${datasetPathToString(path2)}#seek:${q}`;
+function pagedSeekKey(workspace, path2, revision, query, selector2 = NO_INDEX) {
+  const q = "key" in query ? `k=${query.key}` : "fields" in query ? `f=${query.fields.join("\0")}|p=${query.prefix ?? ""}` : "prefix" in query ? `p=${query.prefix}` : `r=${(query.from ?? []).join("\0")}|${(query.to ?? []).join("\0")}`;
+  return `paged:${workspace}:${datasetPathToString(path2)}${selectorKey(selector2)}@${revision}#seek:${q}`;
 }
-function toFindQuery(query) {
+function toFindQuery(query, selector2 = NO_INDEX) {
   const q = query;
-  if (q.type === "key") return { key: q.value };
-  if (q.type === "prefix") return { prefix: q.value };
+  const scope = selector2.index === null ? {} : { index: selector2.index };
+  if (q.type === "key") return { key: q.value, ...scope };
+  if (q.type === "prefix") return { prefix: q.value, ...scope };
+  if (q.type === "range") {
+    const r2 = q.value;
+    const from2 = [...r2.from];
+    const to = [...r2.to];
+    if (from2.length === 0 && to.length === 0) {
+      throw new Error("Data.bindPaged: a range seek names no end — give it a `from`, a `to`, or both");
+    }
+    return from2.length === 0 ? { to, ...scope } : to.length === 0 ? { from: from2, ...scope } : { from: from2, to, ...scope };
+  }
   const f2 = q.value;
   const fields = [...f2.values];
-  return f2.prefix.type === "some" ? { fields, prefix: f2.prefix.value } : { fields };
+  return f2.prefix.type === "some" ? { fields, prefix: f2.prefix.value, ...scope } : { fields, ...scope };
 }
 class PagedRuntime extends TrackedChannelStore {
   constructor() {
     super(...arguments);
     __publicField(this, "api", null);
     __publicField(this, "workspace", null);
-    // Compiled-handle cache (issue #106 perf): buildHandle compiles 2
+    // Compiled-handle cache (issue #106 perf): buildHandle compiles several
     // East.functions per bind, and binds re-run every reactive frame. The
-    // method IR is a pure function of (sourceType, sourcePath), and the methods
-    // resolve api/workspace LIVE, so a cached handle still re-binds.
+    // method IR is a pure function of (sourceType, path, selector, shape), and
+    // the methods resolve api/workspace LIVE, so a cached handle still
+    // re-binds.
     //
     // Keyed by TYPE first, then path — never by path alone. The window decoder
     // is baked from `sourceType`, so a path re-bound at a different type (a
@@ -3774,6 +3959,10 @@ class PagedRuntime extends TrackedChannelStore {
     /** Loaded window keys in least-recently-READ order (a Map preserves
      *  insertion order; a read re-inserts). Bounds the decoded-window cache. */
     __publicField(this, "loadedWindows", /* @__PURE__ */ new Map());
+    /** Each dataset's snapshot, by workspace and path. */
+    __publicField(this, "snapshots", /* @__PURE__ */ new Map());
+    /** Fetches launched so far — the source of every channel's `launchSeq`. */
+    __publicField(this, "launches", 0);
   }
   /** Monotonic clock seam so tests can drive the retry gate. */
   now() {
@@ -3784,17 +3973,33 @@ class PagedRuntime extends TrackedChannelStore {
   }
   // ----- wiring ----------------------------------------------------------
   /** Install the API adapter + workspace — called by the React provider
-   *  (or a test/showcase harness) before any handle is used. */
+   *  (or a test/showcase harness) before any handle is used. Another adapter
+   *  or workspace starts from nothing: no snapshot of the old one's carries
+   *  over. */
   initialize(api3, workspace) {
+    if (this.api !== api3 || this.workspace !== workspace) this.reset();
     this.api = api3;
     this.workspace = workspace;
   }
-  /** Tear down the adapter and all window state. */
-  clear() {
+  /**
+   * Tear down the adapter and all window state.
+   *
+   * @param api - Clear only while this is the installed adapter, so a
+   *   provider tearing down after another installed its own leaves that one
+   *   in place
+   */
+  clear(api3) {
+    if (api3 !== void 0 && this.api !== api3) return;
     this.api = null;
     this.workspace = null;
-    this.clearChannels();
+    this.reset();
     this.handleCache.clear();
+  }
+  /** Stop following every dataset, and drop what every snapshot delivered. */
+  reset() {
+    for (const snapshot of this.snapshots.values()) snapshot.unwatch();
+    this.snapshots.clear();
+    this.clearChannels();
     this.loadedWindows.clear();
   }
   resolveWorkspace() {
@@ -3805,7 +4010,178 @@ class PagedRuntime extends TrackedChannelStore {
     }
     return this.workspace;
   }
-  // ----- window loading --------------------------------------------------
+  // ----- snapshots -------------------------------------------------------
+  /** A dataset's snapshot, followed from its first read until the runtime
+   *  is cleared. */
+  snapshotOf(workspace, path2) {
+    const key = `${workspace}:${datasetPathToString(path2)}`;
+    const existing = this.snapshots.get(key);
+    if (existing !== void 0) return existing;
+    const snapshot = {
+      key,
+      revision: void 0,
+      moves: 0,
+      findSeq: 0,
+      finding: false,
+      channels: /* @__PURE__ */ new Set(),
+      unwatch: () => {
+      }
+    };
+    this.snapshots.set(key, snapshot);
+    if (this.api !== null) {
+      snapshot.unwatch = this.api.watchRevision(workspace, path2, (hash2) => this.moveTo(workspace, path2, snapshot, hash2));
+    }
+    return snapshot;
+  }
+  /** Whether a snapshot is still the runtime's, rather than one a clear or a
+   *  re-initialization dropped. */
+  isLive(snapshot) {
+    return this.snapshots.get(snapshot.key) === snapshot;
+  }
+  /** Whether a live snapshot is still pinned to `revision`. */
+  pinnedTo(snapshot, revision) {
+    return this.isLive(snapshot) && snapshot.revision === revision;
+  }
+  /**
+   * The revision a read of `path` is pinned to — a hash, `null` while the
+   * dataset has no value, or `undefined` while it is being found — tracked so
+   * the read re-fires when the source moves.
+   *
+   * @throws The failed lookup's reason, until a read after the retry gap
+   *   looks again
+   */
+  revisionFor(workspace, path2) {
+    this.track(pagedRevisionKey(workspace, path2));
+    const snapshot = this.snapshotOf(workspace, path2);
+    if (snapshot.revision !== void 0 || snapshot.finding) return snapshot.revision;
+    if (snapshot.findError !== void 0 && this.now() - (snapshot.findFailedAtMs ?? 0) < RETRY_AFTER_MS) {
+      throw new Error(snapshot.findError);
+    }
+    this.find(workspace, path2, snapshot);
+    return void 0;
+  }
+  /**
+   * Ask the server which content the dataset holds, and move there — unless
+   * a move lands first, which came from something no older than the answer.
+   */
+  find(workspace, path2, snapshot) {
+    const seq = ++snapshot.findSeq;
+    const moves = snapshot.moves;
+    snapshot.finding = true;
+    const api3 = this.api;
+    void (async () => {
+      let revision;
+      try {
+        if (api3 === null) throw new Error("no PagedApi installed");
+        revision = await api3.getRevision(workspace, path2);
+      } catch (err) {
+        if (!this.isLive(snapshot) || snapshot.findSeq !== seq) return;
+        snapshot.finding = false;
+        if (snapshot.revision !== void 0) return;
+        snapshot.findError = failureOf(path2, err);
+        snapshot.findFailedAtMs = this.now();
+        console.error(`Data.bindPaged: could not find which content ${datasetPathToString(path2)} holds:`, err);
+        this.notify(pagedRevisionKey(workspace, path2));
+        return;
+      }
+      if (!this.isLive(snapshot) || snapshot.findSeq !== seq) return;
+      snapshot.finding = false;
+      if (snapshot.moves !== moves) return;
+      this.moveTo(workspace, path2, snapshot, revision);
+    })();
+  }
+  /**
+   * Move a dataset's source to `revision`: drop what the old snapshot
+   * delivered and re-fire every read of the dataset, so the windows and
+   * searches still in use are fetched again, pinned to the new one. A move to
+   * the revision the source already has changes nothing.
+   */
+  moveTo(workspace, path2, snapshot, revision) {
+    if (!this.isLive(snapshot) || snapshot.revision === revision) return;
+    snapshot.revision = revision;
+    snapshot.moves += 1;
+    delete snapshot.findError;
+    delete snapshot.findFailedAtMs;
+    for (const key of snapshot.channels) {
+      this.entries.delete(key);
+      this.loadedWindows.delete(key);
+    }
+    snapshot.channels.clear();
+    this.notify(pagedRevisionKey(workspace, path2));
+  }
+  /**
+   * Handle what a pinned fetch threw when it is not the read's failure: a
+   * refusal naming other content moves the source there, and "no value"
+   * moves it to no snapshot. Returns whether the error was one of those, or
+   * arrived after the source had already moved on.
+   */
+  followed(workspace, path2, snapshot, revision, err) {
+    if (!this.pinnedTo(snapshot, revision)) return true;
+    if (err instanceof e3ApiClient.DatasetHashMismatchError) {
+      if (err.currentHash !== null && err.currentHash !== revision) {
+        this.moveTo(workspace, path2, snapshot, err.currentHash);
+        return true;
+      }
+      this.find(workspace, path2, snapshot);
+      return false;
+    }
+    const code = errorCode(err);
+    if (code !== void 0 && NO_VALUE_ERRORS.has(code)) {
+      this.moveTo(workspace, path2, snapshot, null);
+      return true;
+    }
+    return false;
+  }
+  // ----- channels ----------------------------------------------------------
+  /** A channel of the snapshot's current revision, dropped when it moves. */
+  channel(snapshot, key) {
+    snapshot.channels.add(key);
+    return this.entry(key);
+  }
+  /** Whether a channel is due a fetch: never fetched, evicted, or failed
+   *  for a reason a retry can fix, longer ago than the retry gap. */
+  due(entry) {
+    if (entry.status === "idle") return true;
+    if (entry.status !== "failed" || entry.permanent === true) return false;
+    return this.now() - (entry.failedAtMs ?? 0) >= RETRY_AFTER_MS;
+  }
+  /**
+   * Mark a channel's fetch as started, returning the fetch's sequence number.
+   *
+   * Deliberately does NOT notify — the read that triggers it runs inside a
+   * render pass, and notifying there would re-enter the renderer. Only the
+   * settle notifies.
+   */
+  launch(entry) {
+    entry.status = "running";
+    entry.launchSeq = ++this.launches;
+    return entry.launchSeq;
+  }
+  /** Apply a fetch's outcome if the channel still waits on it, re-firing the
+   *  channel's reads. Returns whether it applied. */
+  settle(key, seq, mutate) {
+    const entry = this.entries.get(key);
+    if (entry === void 0 || entry.launchSeq !== seq) return false;
+    mutate(entry);
+    this.notify(key);
+    return true;
+  }
+  /** Settle a fetch as failed, with the reason a read will throw. */
+  fail(key, seq, reason, permanent) {
+    this.settle(key, seq, (e3) => {
+      e3.status = "failed";
+      e3.error = reason;
+      e3.failedAtMs = this.now();
+      e3.permanent = permanent;
+    });
+  }
+  /** What a read of a channel answers: its value once loaded, `none` while
+   *  in flight, or its failure, thrown. */
+  answer(entry, value) {
+    if (entry.status === "loaded" && value !== void 0) return east.some(value);
+    if (entry.status === "failed") throw new Error(entry.error ?? "Data.bindPaged: the read failed");
+    return east.none;
+  }
   /** Note a window as most-recently-read, and drop the coldest decoded
    *  windows once the cache exceeds its cap. An evicted window returns to
    *  `idle`, so the next read refetches it rather than reading a hole. */
@@ -3823,131 +4199,83 @@ class PagedRuntime extends TrackedChannelStore {
       delete entry.window;
     }
   }
-  /**
-   * Start the fetch for a window if it isn't loaded or already in flight.
-   *
-   * Deliberately does NOT notify on launch — the read that triggers it runs
-   * inside a render pass, and notifying there would re-enter the renderer.
-   * Only the settle notifies.
-   */
-  ensureWindow(sourceType, workspace, path2, offset, limit2) {
-    const key = pagedWindowKey(workspace, path2, offset, limit2);
-    const entry = this.entry(key);
-    if (entry.status === "running" || entry.status === "loaded") return;
-    if (entry.status === "failed") {
-      if (entry.permanent) return;
-      const since = this.now() - (entry.failedAtMs ?? 0);
-      if (since < RETRY_AFTER_MS) return;
-    }
-    entry.status = "running";
-    entry.launchSeq += 1;
-    const mySeq = entry.launchSeq;
+  // ----- window loading --------------------------------------------------
+  /** Start the pinned fetch for a window if it is due one, returning its
+   *  channel. */
+  ensureWindow(sourceType, workspace, path2, snapshot, revision, offset, limit2, selector2, key) {
+    const entry = this.channel(snapshot, key);
+    if (!this.due(entry)) return entry;
+    const seq = this.launch(entry);
     const api3 = this.api;
     void (async () => {
-      const settle = (mutate) => {
-        const current = this.entries.get(key);
-        if (!current || current.launchSeq !== mySeq) return;
-        mutate(current);
-        this.notify(key);
-      };
-      if (!api3) {
-        settle((e3) => {
-          e3.status = "failed";
-          e3.failedAtMs = this.now();
-        });
-        console.error("Data.bindPaged: no PagedApi installed");
-        return;
-      }
       let page;
       try {
-        page = await api3.getPage(workspace, path2, { offset, limit: limit2 });
-      } catch (err) {
-        const permanent = isPermanentPageError(err);
-        settle((e3) => {
-          e3.status = "failed";
-          e3.failedAtMs = this.now();
-          e3.permanent = permanent;
+        if (api3 === null) throw new Error("no PagedApi installed");
+        page = await api3.getPage(workspace, path2, {
+          offset,
+          limit: limit2,
+          hash: revision,
+          ...selector2.index !== null && { index: selector2.index, join: selector2.join }
         });
-        console.error(
-          permanent ? `Data.bindPaged: ${datasetPathToString(path2)} is not a pageable dataset — bind a collection (Array / Set / Dict), or use Data.bind for a whole value:` : `Data.bindPaged: fetch failed for ${key}:`,
-          err
-        );
+      } catch (err) {
+        if (this.followed(workspace, path2, snapshot, revision, err)) return;
+        this.fail(key, seq, failureOf(path2, err), isPermanentPageError(err));
+        console.error(`Data.bindPaged: fetch failed for ${key}:`, err);
         return;
       }
+      if (!this.pinnedTo(snapshot, revision)) return;
       let decoded;
       try {
         decoded = east.decodeBeast2For(sourceType)(page.data);
       } catch (err) {
-        settle((e3) => {
-          e3.status = "failed";
-          e3.failedAtMs = this.now();
-        });
+        this.fail(key, seq, `${failureOf(path2, err)} (the window does not decode as the source's type)`, true);
         console.error(`Data.bindPaged: decode failed for ${key}:`, err);
         return;
       }
-      settle((e3) => {
+      const landed = this.settle(key, seq, (e3) => {
         e3.status = "loaded";
         e3.window = decoded;
         e3.total = page.totalElements;
+        delete e3.error;
       });
+      if (!landed) return;
       this.touchWindow(key);
-      const totalKey = pagedTotalKey(workspace, path2);
-      const totalEntry = this.entry(totalKey);
+      const totalKey = pagedTotalKey(workspace, path2, revision, selector2);
+      const totalEntry = this.channel(snapshot, totalKey);
       if (totalEntry.total !== page.totalElements) {
         totalEntry.total = page.totalElements;
         totalEntry.status = "loaded";
         this.notify(totalKey);
       }
     })();
+    return entry;
   }
-  /**
-   * Start the fence search for one key query if it isn't answered or already
-   * in flight — the seek sibling of {@link ensureWindow}, with the same
-   * launch-does-not-notify rule (the read runs inside a render pass).
-   */
-  ensureSeek(workspace, path2, query, key) {
-    const entry = this.entry(key);
-    if (entry.status === "running" || entry.status === "loaded") return;
-    if (entry.status === "failed") {
-      if (entry.permanent) return;
-      const since = this.now() - (entry.failedAtMs ?? 0);
-      if (since < RETRY_AFTER_MS) return;
-    }
-    entry.status = "running";
-    entry.launchSeq += 1;
-    const mySeq = entry.launchSeq;
+  /** Start the pinned fence search for one key query if it is due one,
+   *  returning its channel — the seek sibling of {@link ensureWindow}. */
+  ensureSeek(workspace, path2, snapshot, revision, query, key) {
+    const entry = this.channel(snapshot, key);
+    if (!this.due(entry)) return entry;
+    const seq = this.launch(entry);
     const api3 = this.api;
     void (async () => {
-      const settle = (mutate) => {
-        const current = this.entries.get(key);
-        if (!current || current.launchSeq !== mySeq) return;
-        mutate(current);
-        this.notify(key);
-      };
-      if (!api3) {
-        settle((e3) => {
-          e3.status = "failed";
-          e3.failedAtMs = this.now();
-        });
-        console.error("Data.bindPaged: no PagedApi installed");
-        return;
-      }
+      let range;
       try {
-        const range = await api3.findKey(workspace, path2, query);
-        settle((e3) => {
-          e3.status = "loaded";
-          e3.range = range;
-        });
+        if (api3 === null) throw new Error("no PagedApi installed");
+        range = await api3.findKey(workspace, path2, { ...query, hash: revision });
       } catch (err) {
-        const permanent = isPermanentPageError(err);
-        settle((e3) => {
-          e3.status = "failed";
-          e3.failedAtMs = this.now();
-          e3.permanent = permanent;
-        });
+        if (this.followed(workspace, path2, snapshot, revision, err)) return;
+        this.fail(key, seq, failureOf(path2, err), isPermanentPageError(err));
         console.error(`Data.bindPaged: key search failed for ${key}:`, err);
+        return;
       }
+      if (!this.pinnedTo(snapshot, revision)) return;
+      this.settle(key, seq, (e3) => {
+        e3.status = "loaded";
+        e3.range = range;
+        delete e3.error;
+      });
     })();
+    return entry;
   }
   /**
    * The low-level primitives backing handle methods, bound to THIS runtime.
@@ -3957,53 +4285,92 @@ class PagedRuntime extends TrackedChannelStore {
    */
   buildPrimitives() {
     return [
-      internal$1.DataPagedPrimitives.page.implement((sourceType) => (pathArg, offsetArg, limitArg) => {
+      internal$1.DataPagedPrimitives.page.implement((sourceType) => (pathArg, indexArg, joinArg, offsetArg, limitArg) => {
         const workspace = this.resolveWorkspace();
         const path2 = pathArg;
+        const revision = this.revisionFor(workspace, path2);
+        if (typeof revision !== "string") return east.none;
+        const selector2 = toSelector(indexArg, joinArg);
         const offset = Number(offsetArg);
         const limit2 = Number(limitArg);
-        const key = pagedWindowKey(workspace, path2, offset, limit2);
+        const key = pagedWindowKey(workspace, path2, revision, offset, limit2, selector2);
         this.track(key);
-        this.ensureWindow(sourceType, workspace, path2, offset, limit2);
-        const entry = this.entry(key);
-        if (entry.status === "loaded" && entry.window !== void 0) {
-          this.touchWindow(key);
-          return east.variant("some", entry.window);
-        }
-        return east.variant("none", null);
+        const entry = this.ensureWindow(
+          sourceType,
+          workspace,
+          path2,
+          this.snapshotOf(workspace, path2),
+          revision,
+          offset,
+          limit2,
+          selector2,
+          key
+        );
+        if (entry.status === "loaded" && entry.window !== void 0) this.touchWindow(key);
+        return this.answer(entry, entry.window);
       }),
-      internal$1.DataPagedPrimitives.total.implement((_sourceType) => (pathArg) => {
+      internal$1.DataPagedPrimitives.total.implement((_sourceType) => (pathArg, indexArg, joinArg) => {
         const workspace = this.resolveWorkspace();
-        const key = pagedTotalKey(workspace, pathArg);
+        const path2 = pathArg;
+        const revision = this.revisionFor(workspace, path2);
+        if (typeof revision !== "string") return east.none;
+        const key = pagedTotalKey(workspace, path2, revision, toSelector(indexArg, joinArg));
         this.track(key);
-        const entry = this.entry(key);
-        return entry.total !== void 0 ? east.variant("some", BigInt(entry.total)) : east.variant("none", null);
+        const entry = this.channel(this.snapshotOf(workspace, path2), key);
+        return entry.total !== void 0 ? east.some(BigInt(entry.total)) : east.none;
       }),
-      internal$1.DataPagedPrimitives.seek.implement((_sourceType) => (pathArg, queryArg) => {
+      internal$1.DataPagedPrimitives.seek.implement((_sourceType) => (pathArg, indexArg, joinArg, queryArg) => {
         const workspace = this.resolveWorkspace();
         const path2 = pathArg;
-        const query = toFindQuery(queryArg);
-        const key = pagedSeekKey(workspace, path2, query);
+        const revision = this.revisionFor(workspace, path2);
+        if (typeof revision !== "string") return east.none;
+        const selector2 = toSelector(indexArg, joinArg);
+        const query = toFindQuery(queryArg, selector2);
+        const key = pagedSeekKey(workspace, path2, revision, query, selector2);
         this.track(key);
-        this.ensureSeek(workspace, path2, query, key);
-        const entry = this.entry(key);
-        if (entry.status !== "loaded" || entry.range === void 0) return east.none;
-        const r2 = entry.range;
-        return east.some({ found: r2.found, row: BigInt(r2.row), count: BigInt(r2.count) });
+        const entry = this.ensureSeek(workspace, path2, this.snapshotOf(workspace, path2), revision, query, key);
+        const range = entry.range;
+        return this.answer(entry, range === void 0 ? void 0 : { found: range.found, row: BigInt(range.row), count: BigInt(range.count) });
+      }),
+      internal$1.DataPagedPrimitives.revision.implement((_sourceType) => (pathArg, _indexArg, _joinArg) => {
+        const revision = this.revisionFor(this.resolveWorkspace(), pathArg);
+        return typeof revision === "string" ? east.some(revision) : east.none;
+      }),
+      internal$1.DataPagedPrimitives.refresh.implement((_sourceType) => (pathArg, _indexArg, _joinArg, targetArg) => {
+        const workspace = this.resolveWorkspace();
+        const path2 = pathArg;
+        const target = targetArg;
+        queueMicrotask(() => {
+          if (this.workspace !== workspace) return;
+          const snapshot = this.snapshotOf(workspace, path2);
+          if (target.type === "some") this.moveTo(workspace, path2, snapshot, target.value);
+          else this.find(workspace, path2, snapshot);
+        });
+        return null;
       })
     ];
   }
   /**
-   * Build the handle value for one `Data.bindPaged` evaluation. Both methods
-   * are thin IR-bearing `East.function`s over {@link buildPrimitives},
-   * capturing only the plain-data source path (the value type rides as a
-   * type-arg) — so the handle is ordinary serializable East data (issue #106).
+   * Build the handle value for one paged bind. Every method is a thin
+   * IR-bearing `East.function` over {@link buildPrimitives}, capturing only
+   * the plain-data source path and selector (the value type rides as a
+   * type-arg) — so the handle is ordinary serializable East data (issue
+   * #106).
+   *
+   * @param sourceType - The dataset's type, or an index's window type
+   * @param path - The dataset's path
+   * @param selector - The rows the bind serves
+   * @param shape - `released`: the handle `data_bind_paged` returns, without
+   *   `revision` or `refresh`; `pinned`: the handle `data_bind_paged_pinned`
+   *   returns. Both read through the same snapshot.
+   * @returns The handle
    */
-  buildHandle(sourceType, path2) {
-    const pathKey = datasetPathToString(path2);
+  buildHandle(sourceType, path2, selector2, shape) {
+    const id3 = `${datasetPathToString(path2)}${selectorKey(selector2)}`;
+    const cacheKey = `${id3}#${shape}`;
     let byPath = this.handleCache.get(sourceType);
     if (byPath) {
-      const hit = byPath.get(pathKey);
+      const hit = byPath.get(cacheKey);
       if (hit) return hit;
     } else {
       byPath = /* @__PURE__ */ new Map();
@@ -4011,24 +4378,27 @@ class PagedRuntime extends TrackedChannelStore {
     }
     const T2 = east.fromEastTypeValue(sourceType);
     const pathExpr = east.East.value(path2, e3Types.TreePathType);
+    const indexExpr = east.East.value(selector2.index === null ? east.none : east.some(selector2.index), east.OptionType(east.StringType));
+    const joinExpr = east.East.value(selector2.join, east.BooleanType);
     const platform2 = this.buildPrimitives();
-    const { page, total } = internal$1.DataPagedPrimitives;
+    const { page, total, revision, refresh } = internal$1.DataPagedPrimitives;
     const handle = {
       // The comparable identity east-ui's `PagedSourceType` requires:
       // East compares every function as EQUAL, so a struct of nothing but
       // closures is indistinguishable from any other and a memoized
       // component would never re-render on a source swap (#567 D4). The
-      // dataset path is the natural identity — same path, same rows.
-      id: pathKey,
+      // dataset path and selector are the natural identity — same path,
+      // same rows. The snapshot they serve is `revision`'s, not the id's.
+      id: id3,
       page: east.East.compile(
         east.East.function([east.IntegerType, east.IntegerType], east.OptionType(T2), ($3, offset, limit2) => {
-          $3.return(page([T2], pathExpr, offset, limit2));
+          $3.return(page([T2], pathExpr, indexExpr, joinExpr, offset, limit2));
         }),
         platform2
       ),
       total: east.East.compile(
         east.East.function([], east.OptionType(east.IntegerType), ($3) => {
-          $3.return(total([T2], pathExpr));
+          $3.return(total([T2], pathExpr, indexExpr, joinExpr));
         }),
         platform2
       ),
@@ -4037,28 +4407,50 @@ class PagedRuntime extends TrackedChannelStore {
       // segments) against the stored fences; an Array's stream order has
       // nothing to search. Resolved at bind time from the dataset's own
       // type, so a component renders the affordance only when it works.
-      seek: buildSeek(sourceType, T2, pathExpr, platform2)
+      seek: buildSeek(sourceType, T2, pathExpr, indexExpr, joinExpr, selector2, platform2)
     };
-    byPath.set(pathKey, handle);
+    if (shape === "pinned") {
+      handle.revision = east.East.compile(
+        east.East.function([], east.OptionType(east.StringType), ($3) => {
+          $3.return(revision([T2], pathExpr, indexExpr, joinExpr));
+        }),
+        platform2
+      );
+      handle.refresh = east.East.compile(
+        east.East.function([east.OptionType(east.StringType)], east.NullType, ($3, target) => {
+          $3.return(refresh([T2], pathExpr, indexExpr, joinExpr, target));
+        }),
+        platform2
+      );
+    }
+    byPath.set(cacheKey, handle);
     return handle;
   }
   // ----- platform building -------------------------------------------------
-  /** Build a `Data.bindPaged` PlatformFunction bound to this runtime. Pass
-   *  `allowed=null` for an unscoped impl; pass a Set of path strings for
-   *  manifest scoping. */
+  /** Build the PlatformFunction behind `data_bind_paged` — the bind a UI
+   *  exported before pinned reads calls — bound to this runtime. Its handle
+   *  has no `revision` or `refresh`, but its reads are pinned, follow the
+   *  dataset and fail visibly all the same. Pass `allowed=null` for an
+   *  unscoped impl, or a Set of path strings for manifest scoping. */
   buildPlatform(allowed) {
     return internal$1.bindPagedPlatformFn.implement(
       (sourceType) => (pathArg) => {
         const path2 = pathArg;
-        if (allowed) {
-          const pathStr = datasetPathToString(path2);
-          if (!allowed.has(pathStr)) {
-            throw new Error(
-              `Data.bindPaged: source path "${pathStr}" not declared in manifest — bind it in the task body so derivation records it`
-            );
-          }
-        }
-        return this.buildHandle(sourceType, path2);
+        checkDeclared(allowed, path2);
+        return this.buildHandle(sourceType, path2, NO_INDEX, "released");
+      }
+    );
+  }
+  /** Build the PlatformFunction behind `data_bind_paged_pinned` — what
+   *  `Data.bindPaged` emits, for a dataset's own rows or a record's index —
+   *  bound to this runtime and scoped by `allowed` exactly as
+   *  {@link buildPlatform} is: an index read is a read of the record's path. */
+  buildPinnedPlatform(allowed) {
+    return internal$1.bindPagedPinnedPlatformFn.implement(
+      (sourceType) => (pathArg, indexArg, joinArg) => {
+        const path2 = pathArg;
+        checkDeclared(allowed, path2);
+        return this.buildHandle(sourceType, path2, toSelector(indexArg, joinArg), "pinned");
       }
     );
   }
@@ -4067,17 +4459,19 @@ const defaultPagedRuntime = new PagedRuntime();
 function initializePagedApi(api3, workspace) {
   defaultPagedRuntime.initialize(api3, workspace);
 }
-function clearPagedApi() {
-  defaultPagedRuntime.clear();
+function clearPagedApi(api3) {
+  defaultPagedRuntime.clear(api3);
 }
 const PagedPlatform = [
   defaultPagedRuntime.buildPlatform(null),
+  defaultPagedRuntime.buildPinnedPlatform(null),
   ...defaultPagedRuntime.buildPrimitives()
 ];
 function createScopedPagedPlatform(pages) {
   const allowed = new Set(pages.map((p2) => datasetPathToString(p2)));
   return [
     defaultPagedRuntime.buildPlatform(allowed),
+    defaultPagedRuntime.buildPinnedPlatform(allowed),
     ...defaultPagedRuntime.buildPrimitives()
   ];
 }
@@ -4100,13 +4494,12 @@ function createDefaultFunctionApi(apiUrl, repo, getToken) {
     async call(workspace, fn3, req) {
       return e3ApiClient.workspaceFunctionCall(apiUrl, repo, workspace, fn3, {
         args: req.args,
-        runner: east.variant("none", null),
-        limits: east.variant("none", null)
+        runner: east.none,
+        limits: east.none
       }, opts());
     }
   };
 }
-const eastTypeEqual$1 = east.equalFor(internal.EastTypeType);
 function signatureOfFuncHandleType(handleType) {
   var _a2, _b2;
   if (handleType.type !== "Struct") {
@@ -4203,8 +4596,15 @@ class FuncRuntime extends TrackedChannelStore {
     this.api = api3;
     this.workspace = workspace;
   }
-  /** Tear down the adapter and all call state. */
-  clear() {
+  /**
+   * Tear down the adapter and all call state.
+   *
+   * @param api - Clear only while this is the installed adapter, so a
+   *   provider tearing down after another installed its own leaves that one
+   *   in place
+   */
+  clear(api3) {
+    if (api3 !== void 0 && this.api !== api3) return;
     this.api = null;
     this.workspace = null;
     this.clearChannels();
@@ -4243,8 +4643,8 @@ class FuncRuntime extends TrackedChannelStore {
         stderr: ""
       };
     }
-    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);
+    const inputsMatch = deployed.inputTypes.length === sig.inputs.length && deployed.inputTypes.every((t4, i) => east.isTypeValueEqual(t4, sig.inputs[i]));
+    const outputMatches = east.isTypeValueEqual(deployed.outputType, sig.output);
     if (!inputsMatch || !outputMatches) {
       const message = `signature mismatch for "${name}": bound (${sig.inputs.length} inputs) disagrees with the deployed package`;
       return {
@@ -4347,7 +4747,7 @@ class FuncRuntime extends TrackedChannelStore {
       internal$1.FuncBindPrimitives.read.implement((_outputType) => (nameArg) => {
         const { key, entry } = channel(nameArg);
         runtime.track(key);
-        return entry.result !== void 0 ? east.variant("some", entry.result) : east.variant("none", null);
+        return entry.result !== void 0 ? east.some(entry.result) : east.none;
       }),
       internal$1.FuncBindPrimitives.status.implement((nameArg) => {
         const { key, entry } = channel(nameArg);
@@ -4357,7 +4757,7 @@ class FuncRuntime extends TrackedChannelStore {
       internal$1.FuncBindPrimitives.error.implement((nameArg) => {
         const { key, entry } = channel(nameArg);
         runtime.track(key);
-        return entry.status === "failed" && entry.error !== void 0 ? east.variant("some", entry.error) : east.variant("none", null);
+        return entry.status === "failed" && entry.error !== void 0 ? east.some(entry.error) : east.none;
       }),
       internal$1.FuncBindPrimitives.pending.implement((nameArg) => {
         const { key, entry } = channel(nameArg);
@@ -4437,8 +4837,8 @@ const defaultFuncRuntime = new FuncRuntime();
 function initializeFunctionApi(api3, workspace) {
   defaultFuncRuntime.initialize(api3, workspace);
 }
-function clearFunctionApi() {
-  defaultFuncRuntime.clear();
+function clearFunctionApi(api3) {
+  defaultFuncRuntime.clear(api3);
 }
 const FuncPlatform = [
   defaultFuncRuntime.buildPlatform(null),
@@ -8211,12 +8611,6 @@ function errorOfMutationResult(result) {
         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 }),
@@ -8276,8 +8670,15 @@ class RecordRuntime extends TrackedChannelStore {
     this.cache = cache3;
     this.workspace = workspace;
   }
-  /** Tear down the adapter and all record state. */
-  clear() {
+  /**
+   * Tear down the adapter and all record state.
+   *
+   * @param api - Clear only while this is the installed adapter, so a
+   *   provider tearing down after another installed its own leaves that one
+   *   in place
+   */
+  clear(api3) {
+    if (api3 !== void 0 && this.api !== api3) return;
     this.api = null;
     this.cache = null;
     this.workspace = null;
@@ -8585,8 +8986,8 @@ const defaultRecordRuntime = new RecordRuntime();
 function initializeRecordApi(api3, cache3, workspace) {
   defaultRecordRuntime.initialize(api3, cache3, workspace);
 }
-function clearRecordApi() {
-  defaultRecordRuntime.clear();
+function clearRecordApi(api3) {
+  defaultRecordRuntime.clear(api3);
 }
 const RecordPlatform = [
   defaultRecordRuntime.buildPlatform(null),
@@ -8612,7 +9013,8 @@ function createInMemoryRecordApi(cache3, workspace, defs2) {
       state: `${def.name}-state-0`.padEnd(64, "0"),
       mutation: "$init",
       actor: "memory",
-      at: /* @__PURE__ */ new Date(0)
+      at: /* @__PURE__ */ new Date(0),
+      delta: east.none
     };
     compiled.set(def.name, { stateType, mutations, commits: [genesis], seq: 0 });
     void cache3.write(workspace, recordPath(def.name), east.encodeBeast2For(stateType)(def.initial));
@@ -8644,7 +9046,8 @@ function createInMemoryRecordApi(cache3, workspace, defs2) {
         state: `${record}-state-${c2.seq}`.padEnd(64, "0"),
         mutation,
         actor: "memory",
-        at: /* @__PURE__ */ new Date(0)
+        at: /* @__PURE__ */ new Date(0),
+        delta: east.none
       });
       return { outcome: east.variant("committed", { commitHash: hash2, stateHash: `${record}-state-${c2.seq}`.padEnd(64, "0") }) };
     },
@@ -8693,68 +9096,49 @@ function ReactiveDatasetProvider({
   children: children2
 }) {
   const e3 = useE3Config();
+  const { apiUrl, workspace } = e3;
+  const repo = e3.repo ?? "default";
   const tokenRef = React.useRef(e3.token ?? null);
   tokenRef.current = e3.token ?? null;
-  const api3 = React.useMemo(
-    () => createDefaultDatasetApi(e3.apiUrl, e3.repo ?? "default", () => tokenRef.current),
-    [e3.apiUrl, e3.repo]
-  );
-  const cache3 = React.useMemo(() => {
-    const cfg = {};
-    if (e3.workspace !== void 0) cfg.workspace = e3.workspace;
-    return new ReactiveDatasetCache(cfg, api3);
-  }, [api3, e3.workspace]);
-  React.useMemo(() => {
-    initializeReactiveDatasetCache(cache3);
-    cache3.setScheduler((notify3) => queueMicrotask(notify3));
-  }, [cache3]);
-  React.useMemo(() => {
-    if (e3.workspace !== void 0) {
-      initializeFunctionApi(
-        createDefaultFunctionApi(e3.apiUrl, e3.repo ?? "default", () => tokenRef.current),
-        e3.workspace
-      );
-    }
-  }, [e3.apiUrl, e3.repo, e3.workspace]);
-  React.useMemo(() => {
-    if (e3.workspace !== void 0) {
-      initializePagedApi(
-        createDefaultPagedApi(e3.apiUrl, e3.repo ?? "default", () => tokenRef.current),
-        e3.workspace
-      );
-    }
-  }, [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]);
+  const [installed, setInstalled] = React.useState(null);
   React.useEffect(() => {
+    const getToken = () => tokenRef.current;
+    const cache22 = new ReactiveDatasetCache(
+      workspace !== void 0 ? { workspace } : {},
+      createDefaultDatasetApi(apiUrl, repo, getToken)
+    );
+    cache22.setScheduler((notify3) => queueMicrotask(notify3));
+    initializeReactiveDatasetCache(cache22);
+    const functionApi = createDefaultFunctionApi(apiUrl, repo, getToken);
+    const pagedApi = createDefaultPagedApi(apiUrl, repo, getToken, cache22);
+    const recordApi = createDefaultRecordApi(apiUrl, repo, getToken);
+    if (workspace !== void 0) {
+      initializeFunctionApi(functionApi, workspace);
+      initializePagedApi(pagedApi, workspace);
+      initializeRecordApi(recordApi, cache22, workspace);
+    }
+    const unscopeStaged = getStagedStore().setScope(JSON.stringify([apiUrl, repo]));
+    setInstalled({ apiUrl, repo, workspace, cache: cache22 });
     return () => {
-      const ws = cache3.getConfig().workspace;
-      clearReactiveDatasetCache();
-      clearFunctionApi();
-      clearPagedApi();
-      clearRecordApi();
-      cache3.destroy();
-      if (ws) clearBindingRegistry(ws);
+      clearReactiveDatasetCache(cache22);
+      clearFunctionApi(functionApi);
+      clearPagedApi(pagedApi);
+      clearRecordApi(recordApi);
+      unscopeStaged();
+      cache22.destroy();
+      if (workspace) clearBindingRegistry(workspace);
       else clearBindingRegistry();
     };
-  }, [cache3]);
+  }, [apiUrl, repo, workspace]);
+  const cache3 = installed !== null && installed.apiUrl === apiUrl && installed.repo === repo && installed.workspace === workspace ? installed.cache : null;
   React.useEffect(() => {
-    if (typeof window !== "undefined") {
-      window.__EAST_REACTIVE_DATASET_CACHE__ = cache3;
-    }
+    if (cache3 === null || typeof window === "undefined") return;
+    window.__EAST_REACTIVE_DATASET_CACHE__ = cache3;
     return () => {
-      if (typeof window !== "undefined") {
-        delete window.__EAST_REACTIVE_DATASET_CACHE__;
-      }
+      delete window.__EAST_REACTIVE_DATASET_CACHE__;
     };
   }, [cache3]);
+  if (cache3 === null) return null;
   return /* @__PURE__ */ jsxRuntime.jsx(ReactiveDatasetCacheContext.Provider, { value: cache3, children: children2 });
 }
 function useReactiveDatasetCache() {
@@ -8873,12 +9257,11 @@ function collectLeaves(node2, into = []) {
   else for (const c2 of node2.children) collectLeaves(c2, into);
   return into;
 }
+const readString = east.parseFor(east.StringType);
 function leafDisplayLabel(seg) {
-  if (seg.kind === "key" && typeof seg.key === "string" && seg.key.length >= 2 && seg.key.startsWith('"') && seg.key.endsWith('"')) {
-    try {
-      return JSON.parse(seg.key);
-    } catch {
-    }
+  if (seg.kind === "key") {
+    const read = readString(seg.key);
+    if (read.success) return read.value;
   }
   return east.pathDisplay(seg);
 }
@@ -8930,57 +9313,28 @@ function walkPatchToTree(typeValue, patch, rootLabel) {
   return root2;
 }
 const MAX_INLINE_CHARS = 48;
-function formatLeafValue(typeValue, value) {
-  if (value === null || value === void 0) return "null";
-  if (!typeValue) return "<value>";
-  switch (typeValue.type) {
-    case "Null":
-      return "null";
-    case "Boolean":
-      return value ? "true" : "false";
-    case "Integer":
-      return typeof value === "bigint" ? value.toString() : String(value);
-    case "Float":
-      return formatFloat(value);
-    case "String":
-      return value === "" ? '""' : String(value);
-    case "DateTime":
-      return value instanceof Date ? value.toISOString() : String(value);
-    case "Blob":
-      return value instanceof Uint8Array ? `${value.length} bytes` : truncate(east.printFor(typeValue)(value));
-    case "Variant":
-      if (east.isVariant(value)) {
-        const cases = typeValue.value;
-        const sub = cases.find((c2) => c2.name === value.type);
-        if (value.value === null || value.value === void 0 || !sub) return value.type;
-        return `${value.type}(${truncate(east.printFor(sub.type)(value.value))})`;
-      }
-      return "<value>";
-    default:
-      return truncate(east.printFor(typeValue)(value));
-  }
-}
-function formatFloat(v3) {
-  if (typeof v3 !== "number") return String(v3);
-  if (Number.isInteger(v3)) return v3.toFixed(1);
-  return Math.abs(v3) >= 1e3 ? v3.toLocaleString("en-US", { maximumFractionDigits: 2 }) : String(Number(v3.toFixed(4)));
+function formatLeafValue(leafType, value, words = eastUiComponents.formatters()) {
+  if (leafType.type === "Float") return words.float(value);
+  const text = east.printFor(leafType)(value);
+  return leafType.type === "String" ? text : truncate(text);
 }
 function truncate(s2) {
   return s2.length > MAX_INLINE_CHARS ? s2.slice(0, MAX_INLINE_CHARS - 1) + "…" : s2;
 }
-function formatBindingLabel(segments) {
-  if (segments.length === 0) return "(root)";
-  const last2 = segments[segments.length - 1];
-  if (last2 && typeof last2 === "object" && "type" in last2) {
-    if (last2.type === "field") return String(last2.value);
-    if (last2.type === "index") return `[${String(last2.value)}]`;
-    if (last2.type === "key") return String(last2.value);
+function formatBindingLabel(path2) {
+  const last2 = path2[path2.length - 1];
+  if (last2 === void 0) return "(root)";
+  switch (last2.type) {
+    case "field":
+      return last2.value;
   }
-  return String(last2);
 }
-function isPrimitiveLeafType(t4) {
-  if (!t4) return false;
-  switch (t4.type) {
+const DATETIME_LOCAL = internal.tokenizeDateTimeFormat("YYYY-MM-DDTHH:mm");
+const readBoolean = east.parseFor(east.BooleanType);
+const readInteger = east.parseFor(east.IntegerType);
+const readFloat = east.parseFor(east.FloatType);
+function isPrimitiveLeafType(leafType) {
+  switch (leafType.type) {
     case "Boolean":
     case "Integer":
     case "Float":
@@ -8992,49 +9346,46 @@ function isPrimitiveLeafType(t4) {
   }
 }
 function formatManualDraft(leafType, value) {
-  if (!leafType || value === void 0 || value === null) return "";
+  if (value === void 0) return "";
   switch (leafType.type) {
     case "Boolean":
-      return value ? "true" : "false";
     case "Integer":
-      return typeof value === "bigint" ? value.toString() : String(value);
     case "Float":
-      return typeof value === "number" ? String(value) : String(value);
+      return east.printFor(leafType)(value);
     case "String":
-      return String(value);
-    case "DateTime": {
-      if (!(value instanceof Date)) return String(value);
-      return value.toISOString().slice(0, 16);
-    }
+      return value;
+    case "DateTime":
+      return internal.formatDateTime(value, DATETIME_LOCAL);
     default:
       return "";
   }
 }
 function parseManualDraft(leafType, draft) {
-  try {
-    switch (leafType.type) {
-      case "Integer":
-        return { ok: true, value: BigInt(draft) };
-      case "Float": {
-        const n2 = Number(draft);
-        if (Number.isNaN(n2)) return { ok: false };
-        return { ok: true, value: n2 };
-      }
-      case "String":
-        return { ok: true, value: draft };
-      case "DateTime": {
-        const d2 = new Date(draft);
-        if (Number.isNaN(d2.getTime())) return { ok: false };
-        return { ok: true, value: d2 };
-      }
-      default:
-        return { ok: false };
+  switch (leafType.type) {
+    case "Boolean": {
+      const read = readBoolean(draft);
+      return read.success ? { ok: true, value: read.value } : { ok: false };
     }
-  } catch {
-    return { ok: false };
+    case "Integer": {
+      const read = readInteger(draft);
+      return read.success ? { ok: true, value: read.value } : { ok: false };
+    }
+    case "Float": {
+      const read = readFloat(draft);
+      return read.success ? { ok: true, value: read.value } : { ok: false };
+    }
+    case "String":
+      return { ok: true, value: draft };
+    case "DateTime": {
+      const read = internal.parseDateTimeFormatted(draft, DATETIME_LOCAL);
+      return read.success ? { ok: true, value: read.value } : { ok: false };
+    }
+    default:
+      return { ok: false };
   }
 }
-const diffValueEqual = east.equalFor(internal$1.Diff.Component.schema);
+const diffValueEqual = east.equivalentFor(internal$1.Diff.Component.schema);
+const diffValueDataEqual = east.equalFor(internal$1.Diff.Component.schema);
 function getOpt$1(opt) {
   return opt.type === "some" ? opt.value : void 0;
 }
@@ -9260,6 +9611,7 @@ function ActionBtn({
   );
 }
 const DiffRow = React.memo(function DiffRow2({ row, depth, bindingPathStr, showActions, onDiscard, annotation, metrics }) {
+  const words = eastUiComponents.useFormatters();
   const handleDiscard = React.useCallback(() => onDiscard(bindingPathStr, row.path), [onDiscard, bindingPathStr, row.path]);
   return /* @__PURE__ */ jsxRuntime.jsxs(
     react.Box,
@@ -9292,7 +9644,7 @@ const DiffRow = React.memo(function DiffRow2({ row, depth, bindingPathStr, showA
           row.stale && /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { fontSize: "11px", color: "fg.warning", fontWeight: 500, children: [
             /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faTriangleExclamation }),
             " ",
-            row.stale.actual === void 0 ? "stale — source no longer has this entry" : `stale — source actually has ${formatLeafValue(row.leafType, row.stale.actual)}`
+            row.stale.actual === void 0 ? "stale — source no longer has this entry" : `stale — source actually has ${formatLeafValue(row.leafType, row.stale.actual, words)}`
           ] }),
           annotation && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "11px", color: `${annotation.tone}.700`, fontWeight: 500, children: annotation.text })
         ] }),
@@ -9301,13 +9653,13 @@ const DiffRow = React.memo(function DiffRow2({ row, depth, bindingPathStr, showA
             row.before !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(Chip$1, { fontSize: metrics.chipFontSize, children: [
               /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", color: "fg.danger", children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faMinus }) }),
               " ",
-              formatLeafValue(row.leafType, row.before)
+              formatLeafValue(row.leafType, row.before, words)
             ] }),
             row.before !== void 0 && row.after !== void 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", color: "fg.subtle", fontSize: "11px", children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faArrowRight }) }),
             row.after !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(Chip$1, { fontSize: metrics.chipFontSize, children: [
               /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", color: "fg.success", children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faPlus }) }),
               " ",
-              formatLeafValue(row.leafType, row.after)
+              formatLeafValue(row.leafType, row.after, words)
             ] })
           ] }),
           showActions && /* @__PURE__ */ jsxRuntime.jsx(ActionBtn, { icon: faXmark, title: "Discard this change", onClick: handleDiscard, size: metrics.actionBtnSize })
@@ -9316,9 +9668,11 @@ const DiffRow = React.memo(function DiffRow2({ row, depth, bindingPathStr, showA
     }
   );
 });
+const REMOVED = "(removed)";
 const ConflictRow = React.memo(function ConflictRow2({ row, depth, bindingPathStr, serverValue, resolution, onResolve, metrics }) {
-  const yoursStr = formatLeafValue(row.leafType, row.after);
-  const theirsStr = formatLeafValue(row.leafType, serverValue);
+  const words = eastUiComponents.useFormatters();
+  const yoursStr = row.after === void 0 ? REMOVED : formatLeafValue(row.leafType, row.after, words);
+  const theirsStr = serverValue === void 0 ? REMOVED : formatLeafValue(row.leafType, serverValue, words);
   const isYours = (resolution == null ? void 0 : resolution.type) === "keepA";
   const isTheirs = (resolution == null ? void 0 : resolution.type) === "keepB";
   const isManual = (resolution == null ? void 0 : resolution.type) === "manual";
@@ -9384,7 +9738,7 @@ const ConflictRow = React.memo(function ConflictRow2({ row, depth, bindingPathSt
                 {
                   selected: isManual,
                   leafType: row.leafType,
-                  value: isManual ? resolution.value : row.after,
+                  value: (resolution == null ? void 0 : resolution.type) === "manual" ? resolution.value : row.after,
                   onChange: handleManual
                 }
               )
@@ -9501,9 +9855,8 @@ function ManualEditor({
   const fire = React.useCallback((parsed) => {
     queueMicrotask(() => onChange2(parsed));
   }, [onChange2]);
-  if (!leafType) return null;
   if (leafType.type === "Boolean") {
-    const checked = !!value;
+    const checked = value === true;
     return /* @__PURE__ */ jsxRuntime.jsxs(
       react.Box,
       {
@@ -9685,9 +10038,10 @@ const EastChakraDiff = React.memo(function EastChakraDiff2({ value }) {
   const [conflicts, setConflicts] = React.useState(null);
   const [resolutions, setResolutions] = React.useState(/* @__PURE__ */ new Map());
   const [committing, setCommitting] = React.useState(false);
+  const data4 = eastUiComponents.useDataStable(value, diffValueDataEqual);
   const irBindings = React.useMemo(
-    () => value.bindings ?? [],
-    [value.bindings]
+    () => data4.bindings ?? [],
+    [data4.bindings]
   );
   const interactive = !(getOpt$1(value.readonly) ?? false);
   const onCommittedFn = getOpt$1(value.onCommitted);
@@ -9721,7 +10075,7 @@ const EastChakraDiff = React.memo(function EastChakraDiff2({ value }) {
   React.useEffect(() => {
     setConflicts(null);
     setResolutions(/* @__PURE__ */ new Map());
-  }, [value, stagedVersion, datasetVersion]);
+  }, [data4, stagedVersion, datasetVersion]);
   const visibleBindings = React.useMemo(
     () => bindings.filter((b2) => b2.leaves.length > 0),
     [bindings]
@@ -23100,13 +23454,13 @@ var hashIterableInts = function hashIterableInts2(iterator) {
   }
   return hash2;
 };
-var hashInt = function hashInt2(num2) {
+var hashInt = function hashInt2(num) {
   var seed = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_HASH_SEED;
-  return seed * K + num2 | 0;
+  return seed * K + num | 0;
 };
-var hashIntAlt = function hashIntAlt2(num2) {
+var hashIntAlt = function hashIntAlt2(num) {
   var seed = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_HASH_SEED_ALT;
-  return (seed << 5) + seed + num2 | 0;
+  return (seed << 5) + seed + num | 0;
 };
 var combineHashes = function combineHashes2(hash1, hash2) {
   return hash1 * 2097152 + hash2;
@@ -23136,7 +23490,7 @@ var hashIntsArray = function hashIntsArray2(ints, seed) {
   };
   return hashIterableInts(iterator, seed);
 };
-var hashString$1 = function hashString(str, seed) {
+var hashString = function hashString2(str, seed) {
   var entry = {
     value: 0,
     done: false
@@ -23163,9 +23517,9 @@ var hashStringsArray = function hashStringsArray2(strs) {
   for (var i = 0; i < strs.length; i++) {
     var str = strs[i];
     if (i === 0) {
-      hash2 = hashString$1(str);
+      hash2 = hashString(str);
     } else {
-      hash2 = hashString$1(str, hash2);
+      hash2 = hashString(str, hash2);
     }
   }
   return hash2;
@@ -30303,7 +30657,7 @@ var cache = function cache2(fn3, name) {
       var _p = eles[0]._private;
       var tch = _p.traversalCache = _p.traversalCache || {};
       var ch = tch[name] = tch[name] || [];
-      var hash2 = hashString$1(key);
+      var hash2 = hashString(key);
       var cacheHit = ch[hash2];
       if (cacheHit) {
         return cacheHit;
@@ -32909,13 +33263,13 @@ function styleCache(key, fn3, ele) {
   }
 }
 function cacheStyleFunction(key, fn3) {
-  key = hashString$1(key);
+  key = hashString(key);
   return function cachedStyleFunction(ele) {
     return styleCache(key, fn3, ele);
   };
 }
 function cachePrototypeStyleFunction(key, fn3) {
-  key = hashString$1(key);
+  key = hashString(key);
   var selfFn = function selfFn2(ele) {
     return fn3.call(ele);
   };
@@ -43186,7 +43540,7 @@ BRp$9.applyLabelDimensions = function(ele) {
 BRp$9.applyPrefixedLabelDimensions = function(ele, prefix2) {
   var _p = ele._private;
   var text = this.getLabelText(ele, prefix2);
-  var cacheKey = hashString$1(text, ele._private.labelDimsKey);
+  var cacheKey = hashString(text, ele._private.labelDimsKey);
   if (getPrefixedProperty(_p.rscratch, "prefixedLabelDimsKey", prefix2) === cacheKey) {
     return;
   }
@@ -47582,7 +47936,7 @@ CRp$9.drawArrowShape = function(edge, context, fill, edgeWidth, shape, shapeWidt
   var shapeImpl = r2.arrowShapes[shape];
   if (usePaths) {
     var cache3 = r2.arrowPathCache = r2.arrowPathCache || [];
-    var key = hashString$1(shape);
+    var key = hashString(shape);
     var cachedPath = cache3[key];
     if (cachedPath != null) {
       path2 = context = cachedPath;
@@ -57964,7 +58318,7 @@ function useBindingValue(binding) {
     try {
       return { value: handle.read(), pending: handle.pending(), error: void 0 };
     } catch (e3) {
-      console.error(`[Experiment] failed to read binding "${String(sourcePath)}":`, e3);
+      console.error(`[Experiment] failed to read binding "${e3Types.pathToString(sourcePath)}":`, e3);
       return { value: null, pending: false, error: e3 };
     }
   }, [handle, version2]);
@@ -57980,20 +58334,25 @@ function useBindingValue(binding) {
   }, [handle]);
   return { value, mode, pending, error: error3, mutate, commit, discard };
 }
+function sameType(a2, b2) {
+  return east.isTypeValueEqual(east.toEastTypeValue(a2), east.toEastTypeValue(b2));
+}
+function sameSignature(a2, b2) {
+  const ai = a2.inputs;
+  const bi = b2.inputs;
+  return sameType(a2.output, b2.output) && (ai === null || bi === null ? ai === bi : ai.length === bi.length && ai.every((t4, i) => sameType(t4, bi[i])));
+}
 const IDLE = { call: () => {
 }, result: null, status: "idle", pending: false, error: null };
 function useFuncCall(name, inputs, output2) {
   const workspace = getReactiveDatasetCache().getConfig().workspace ?? "";
   const ready4 = !!name && !!inputs && workspace !== "";
-  const sigKey = React.useMemo(
-    () => ready4 ? JSON.stringify([inputs.map((t4) => east.toEastTypeValue(t4)), east.toEastTypeValue(output2)]) : "",
-    [ready4, inputs, output2]
-  );
+  const signature = eastUiComponents.useDataStable({ inputs, output: output2 }, sameSignature);
   const handle = React.useMemo(() => {
-    if (!ready4) return null;
-    const handleType = east.toEastTypeValue(internal$1.FuncBindHandleType(inputs, output2));
+    if (!ready4 || signature.inputs === null) return null;
+    const handleType = east.toEastTypeValue(internal$1.FuncBindHandleType(signature.inputs, signature.output));
     return defaultFuncRuntime.buildHandle(handleType, name);
-  }, [ready4, name, workspace, sigKey]);
+  }, [ready4, name, workspace, signature]);
   const channelKey = ready4 ? funcChannelKey(workspace, name) : "";
   const version2 = React.useSyncExternalStore(
     React.useCallback(
@@ -58004,7 +58363,6 @@ 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";
@@ -58016,10 +58374,7 @@ function useFuncCall(name, inputs, output2) {
       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 ?? "" };
-      }
+      if (err.type === "some") error3 = err.value;
     } catch {
     }
     return { call: (...args) => {
@@ -60637,207 +60992,14 @@ function GuidanceToggle({ on: on3, onToggle }) {
     }
   ) });
 }
-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 } : {} };
-}
-function useMeasuredWidth() {
-  const ref = React.useRef(null);
-  const [w2, setW] = React.useState(0);
-  React.useLayoutEffect(() => {
-    const el = ref.current;
-    if (!el) return;
-    const update2 = () => setW(el.clientWidth);
-    update2();
-    const ro = new ResizeObserver(update2);
-    ro.observe(el);
-    return () => ro.disconnect();
-  }, []);
-  return [ref, w2];
-}
-function useChartTheme() {
-  const system = react.useChakraContext();
-  const tok = (k2, fallback) => system.token(k2, fallback);
-  const tones = {
-    neg: tok("colors.fg.danger", "#b85a4a"),
-    pos: tok("colors.fg.success", "#2f7a5b"),
-    warn: tok("colors.fg.warning", "#b8862d"),
-    muted: tok("colors.fg.muted", "#6b8080"),
-    brand: tok("colors.brand.solid", "#3a7780")
-  };
-  return {
-    mono: tok("fonts.mono", '"JetBrains Mono", ui-monospace, monospace'),
-    body: tok("fonts.body", "system-ui, -apple-system, sans-serif"),
-    ink: tok("colors.fg", "#111b22"),
-    muted: tones.muted,
-    faint: tok("colors.fg.subtle", "#9bb0b0"),
-    rule: tok("colors.border.subtle", "#e2e8e8"),
-    ruleStrong: tok("colors.border.strong", "#cbd5d5"),
-    surface: tok("colors.bg.surface", "#ffffff"),
-    tone: (t4) => tones[t4] ?? tones.brand,
-    labelSize: 10,
-    titleSize: 11,
-    lineWidth: 1.8,
-    barWidth: 2.5,
-    dotRadius: 2.6,
-    scatterRadius: 3.4,
-    areaOpacity: 0.16
-  };
-}
-const fmt$2 = (n2) => Number.isInteger(n2) ? String(n2) : n2.toFixed(1);
-const signed$1 = (n2) => (n2 > 0 ? "+" : "") + fmt$2(n2);
-const niceCeil = (v3) => {
-  if (v3 <= 1e-9) return 0;
-  const mag = Math.pow(10, Math.floor(Math.log10(v3)));
-  const n2 = v3 / mag;
-  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, rowHelp }) {
-  const t4 = useChartTheme();
-  const [ref, w2] = useMeasuredWidth();
-  const n2 = rows.length;
-  const hPx = height2 ?? 26 + n2 * 38;
-  const padL = 124, padR = 46, padT = 20, padB = 30;
-  const innerW = Math.max(0, w2 - padL - padR);
-  const innerH = hPx - padT - padB;
-  const x2 = createLinearScale({ domain: [min4, max5], range: [0, innerW] });
-  const rowH = innerH / Math.max(1, n2);
-  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: 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);
-      return /* @__PURE__ */ jsxRuntime.jsxs(Group, { top: cy, children: [
-        /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: x2(r2.lo), y: 0 }, to: { x: x2(r2.hi), y: 0 }, stroke: col, strokeWidth: t4.barWidth, strokeOpacity: 0.9, strokeLinecap: "round" }),
-        /* @__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(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: 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: 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, yFormat = "signed" }) {
-  const t4 = useChartTheme();
-  const [ref, w2] = useMeasuredWidth();
-  const hPx = height2 ?? 100;
-  const col = t4.tone(toneName ?? "brand");
-  const padL = yTicks.length ? 52 : 6;
-  const padR = 12;
-  const padT = marks.length ? 22 : 8;
-  const padB = xTicks.length ? 22 : 12;
-  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 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 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: [
-      /* @__PURE__ */ jsxRuntime.jsx("text", { x: -8, y: 10, textAnchor: "end", style: svgText(t4.labelSize, t4.muted, t4.mono), children: yLabels[0] }),
-      /* @__PURE__ */ jsxRuntime.jsx("text", { x: -8, y: innerH / 2 + 3, textAnchor: "end", style: svgText(t4.labelSize, t4.muted, t4.mono), children: yLabels[1] }),
-      /* @__PURE__ */ jsxRuntime.jsx("text", { x: -8, y: innerH - 1, textAnchor: "end", style: svgText(t4.labelSize, t4.muted, t4.mono), children: yLabels[2] })
-    ] }),
-    zero2 != null && /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: 0, y: yScale(zero2) }, to: { x: innerW, y: yScale(zero2) }, stroke: t4.muted, strokeWidth: 1, strokeDasharray: "3 2" }),
-    /* @__PURE__ */ jsxRuntime.jsx(Area, { data: data4, x: (d2) => xScale(d2.i), y0: (d2) => yScale(d2.lo), y1: (d2) => yScale(d2.hi), curve: monotoneX, fill: col, fillOpacity: t4.areaOpacity, stroke: "transparent" }),
-    /* @__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(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.5 + 8;
-      const labX = atEnd ? -labW - 5 : atStart ? 5 : -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(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 }),
-    xTicks.map((tk, i) => {
-      const word = Number.isNaN(Number(tk));
-      return /* @__PURE__ */ jsxRuntime.jsx("text", { x: innerW * i / Math.max(1, xTicks.length - 1), y: innerH + 14, textAnchor: i === 0 ? "start" : i === xTicks.length - 1 ? "end" : "middle", style: svgText(word ? 9 : t4.labelSize, word ? t4.faint : t4.muted, word ? t4.body : t4.mono), children: tk }, `x${i}`);
-    })
-  ] }) }) });
-}
-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 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 ONE_DECIMAL = east.variant("number", { minimumFractionDigits: east.some(1n), maximumFractionDigits: east.some(1n), signDisplay: east.none });
+const formatOf = (x2) => Number.isInteger(x2) ? void 0 : ONE_DECIMAL;
+const fmt$1 = (x2, words) => words.value(Math.abs(x2) < 0.05 ? 0 : x2, formatOf(x2));
+const signed = (x2, words) => words.value(x2, formatOf(x2), true);
 const clamp01 = (x2) => x2 < 0 ? 0 : x2 > 1 ? 1 : x2;
+const compareFloats = east.compareFor(east.FloatType);
 function band(absStd) {
   if (absStd >= 0.66) return { level: "large gap", tone: "neg" };
   if (absStd >= 0.33) return { level: "some", tone: "warn" };
@@ -60887,7 +61049,7 @@ function treatmentKind(cols, treatment) {
       return "value";
   }
 }
-function deriveSpec(config2, cols, result, meta3, dataLen, subject) {
+function deriveSpec(config2, cols, result, meta3, dataLen, subject, words) {
   const outUnit = unitOf(meta3, config2.outcome);
   const balByCol = /* @__PURE__ */ new Map();
   for (const b2 of (result == null ? void 0 : result.balance) ?? []) {
@@ -60925,24 +61087,24 @@ function deriveSpec(config2, cols, result, meta3, dataLen, subject) {
     // n_total belongs to the Answer-tab counts strip; labelling the header
     // with it desyncs from the data after a population edit (and reads
     // wrong whenever the two legitimately differ).
-    dataLabel: `${dataLen} ${subject.many}`
+    dataLabel: `${words.number(dataLen)} ${subject.many}`
   };
 }
-function balanceDisplay(b2, categorical) {
+function balanceDisplay(b2, categorical, words) {
   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)}`;
+  return isProp ? `${words.percent(b2.treated_mean)} vs ${words.percent(b2.control_mean)}` : `${words.value(b2.treated_mean, ONE_DECIMAL)} vs ${words.value(b2.control_mean, ONE_DECIMAL)}`;
 }
-function deriveAnswer(config2, result, adj, meta3) {
+function deriveAnswer(config2, result, adj, meta3, words) {
   const ci = eastUiComponents.getSomeorUndefined(adj.ci);
   const nci = eastUiComponents.getSomeorUndefined(result.naive_ci);
   const categorical = new Set(eastUiComponents.getSomeorUndefined(config2.categorical) ?? []);
-  const balance = [...result.balance].sort((a2, b2) => Math.abs(b2.std_diff) - Math.abs(a2.std_diff)).map((b2) => ({
+  const balance = [...result.balance].sort((a2, b2) => compareFloats(Math.abs(b2.std_diff), Math.abs(a2.std_diff))).map((b2) => ({
     // One-hot rows are `col=level` — label the BASE confounder, keep the level.
     col: b2.column,
     label: b2.column === b2.base_column ? labelOf(meta3, b2.base_column) : `${labelOf(meta3, b2.base_column)}${b2.column.startsWith(b2.base_column) ? b2.column.slice(b2.base_column.length) : ` (${b2.column})`}`,
     treated: b2.treated_mean,
     control: b2.control_mean,
-    display: balanceDisplay(b2, categorical),
+    display: balanceDisplay(b2, categorical, words),
     frac: clamp01(Math.abs(b2.std_diff)),
     tone: band(Math.abs(b2.std_diff)).tone
   }));
@@ -60973,12 +61135,12 @@ function deriveAnswer(config2, result, adj, meta3) {
     balance
   };
 }
-function deriveNarrative(result, a2, refute, higherBetter, subject) {
+function deriveNarrative(result, a2, refute, higherBetter, subject, words) {
   if (a2 === null) return null;
   const unit2 = a2.unit ? ` ${a2.unit}` : "";
   const dirUp = a2.effect > 0;
   const verb = higherBetter === void 0 ? dirUp ? "raises" : "lowers" : dirUp === higherBetter ? "improves" : "worsens";
-  const range = ` (likely between ${signed(a2.lo)} and ${signed(a2.hi)})`;
+  const range = ` (likely between ${signed(a2.lo, words)} and ${signed(a2.hi, words)})`;
   const passed = (refute == null ? void 0 : refute.checks.filter((c2) => c2.passed).length) ?? 0;
   const total = (refute == null ? void 0 : refute.checks.length) ?? 0;
   const trustClause = total === 0 ? "" : passed === total ? ` It held up against all ${total} ways we tried to break it.` : ` It passed ${passed} of ${total} stress tests — see “Can we trust it?”.`;
@@ -60989,13 +61151,13 @@ function deriveNarrative(result, a2, refute, higherBetter, subject) {
         segments: [
           { text: "Yes — ", strong: true },
           { text: `${a2.treatment} genuinely ${verb} ${a2.outcome}: about ` },
-          { text: `${signed(a2.effect)}${unit2}`, strong: true },
+          { text: `${signed(a2.effect, words)}${unit2}`, strong: true },
           { text: ` per ${subject.one}${range}.${trustClause}` }
         ]
       };
     case "modest": {
       const tags = new Set(result.verdict_reasons.map((v3) => v3.type));
-      const why = tags.has("not_material") ? ` — the change (${signed(a2.effect)}${unit2}) is smaller than what would matter here (±${fmt$1(result.materiality_threshold)}${unit2}).` : tags.has("ci_spans_zero") ? ` — the likely range (${signed(a2.lo)} to ${signed(a2.hi)}) includes zero.` : tags.has("thin_support") ? " — too few treated and untreated look-alikes overlap to be confident." : tags.has("low_robustness") ? " — a fairly weak hidden factor could overturn it." : a2.lo <= 0 && a2.hi >= 0 ? ` — the likely range (${signed(a2.lo)} to ${signed(a2.hi)}) includes zero.` : ".";
+      const why = tags.has("not_material") ? ` — the change (${signed(a2.effect, words)}${unit2}) is smaller than what would matter here (±${fmt$1(result.materiality_threshold, words)}${unit2}).` : tags.has("ci_spans_zero") ? ` — the likely range (${signed(a2.lo, words)} to ${signed(a2.hi, words)}) includes zero.` : tags.has("thin_support") ? " — too few treated and untreated look-alikes overlap to be confident." : tags.has("low_robustness") ? " — a fairly weak hidden factor could overturn it." : a2.lo <= 0 && a2.hi >= 0 ? ` — the likely range (${signed(a2.lo, words)} to ${signed(a2.hi, words)}) includes zero.` : ".";
       return {
         tone: "warn",
         segments: [
@@ -61010,14 +61172,14 @@ function deriveNarrative(result, a2, refute, higherBetter, subject) {
         tone: "warn",
         segments: [
           { text: "Don’t act on this yet — ", strong: true },
-          { text: `we got a number (${signed(a2.effect)}${unit2}), but a stress test failed: something we didn’t adjust for may still be driving it.` }
+          { text: `we got a number (${signed(a2.effect, words)}${unit2}), but a stress test failed: something we didn’t adjust for may still be driving it.` }
         ]
       };
     default:
       return null;
   }
 }
-function deriveRefusal(config2, result, meta3, subject) {
+function deriveRefusal(config2, result, meta3, subject, words) {
   const nT = Number(result.n_treated), nC = Number(result.n_control), nTot = Number(result.n_total);
   const treatment = labelOf(meta3, config2.treatment);
   if (result.verdict.type === "not_estimable") {
@@ -61027,22 +61189,22 @@ function deriveRefusal(config2, result, meta3, subject) {
       title: `Can’t estimate the effect of ${treatment}`,
       body: reason,
       evidence: [
-        { label: "treated", value: String(nT) },
-        { label: "untreated", value: String(nC) },
-        { label: subject.many, value: String(nTot) }
+        { label: "treated", value: words.number(nT) },
+        { label: "untreated", value: words.number(nC) },
+        { label: subject.many, value: words.number(nTot) }
       ]
     };
   }
   if (result.verdict.type === "non_identifiable_positivity") {
-    const pct = Math.round(result.overlap.common_support_frac * 100);
+    const pct = words.percent(result.overlap.common_support_frac);
     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.`,
+      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) }
+        { label: "common support", value: pct },
+        { label: "treated", value: words.number(nT) },
+        { label: "untreated", value: words.number(nC) }
       ]
     };
   }
@@ -61051,20 +61213,19 @@ function deriveRefusal(config2, result, meta3, subject) {
     title: `Can’t estimate the effect of ${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: subject.many, value: String(nTot) }
+      { label: "treated", value: words.number(nT) },
+      { label: "untreated", value: words.number(nC) },
+      { label: subject.many, value: words.number(nTot) }
     ]
   };
 }
-function deriveOverlap(o2) {
-  const pct = Math.round(o2.common_support_frac * 100);
+function deriveOverlap(o2, words) {
   return {
     treated: arr(o2.treated_propensity),
     control: arr(o2.control_propensity),
     commonSupportFrac: o2.common_support_frac,
     positivityOk: o2.positivity_ok,
-    supportLabel: `${pct}% common support`
+    supportLabel: `${words.percent(o2.common_support_frac)} common support`
   };
 }
 function zeroCrossing(xs, ys) {
@@ -61077,7 +61238,7 @@ function zeroCrossing(xs, ys) {
   }
   return null;
 }
-function deriveRefute(r2, adj, meta3) {
+function deriveRefute(r2, adj, meta3, words) {
   const checks = [];
   const est = (adj == null ? void 0 : adj.effect) ?? 0;
   const placeboEffect = eastUiComponents.getSomeorUndefined(r2.placebo_effect);
@@ -61090,7 +61251,7 @@ function deriveRefute(r2, adj, meta3) {
       desc: "Shuffle which rows were treated; a real effect should collapse to zero.",
       // Speak the outcome, not the statistic: on fake labels the effect
       // should VANISH — say whether it did.
-      value: placeboEffect !== void 0 ? passed ? `vanished (${signed(placeboEffect)})` : `didn’t vanish (${signed(placeboEffect)})` : passed ? "vanished" : "didn’t vanish",
+      value: placeboEffect !== void 0 ? passed ? `vanished (${signed(placeboEffect, words)})` : `didn’t vanish (${signed(placeboEffect, words)})` : passed ? "vanished" : "didn’t vanish",
       passed,
       tip: east.some("Randomly re-label which rows were treated. A genuine effect should vanish."),
       help: "check_shuffle"
@@ -61104,7 +61265,7 @@ function deriveRefute(r2, adj, meta3) {
       name: "Drop-some test",
       short: "drop-some",
       desc: "Re-estimate on random subsamples; a trustworthy effect stays put.",
-      value: passed ? `stayed at ${signed(ds)} ± ${fmt$1(dstd)}` : `moved to ${signed(ds)} ± ${fmt$1(dstd)}`,
+      value: passed ? `stayed at ${signed(ds, words)} ± ${fmt$1(dstd, words)}` : `moved to ${signed(ds, words)} ± ${fmt$1(dstd, words)}`,
       passed,
       tip: east.none,
       help: "check_dropsome"
@@ -61124,14 +61285,14 @@ function deriveRefute(r2, adj, meta3) {
   }
   const sens = eastUiComponents.getSomeorUndefined(r2.sensitivity);
   const evalue = eastUiComponents.getSomeorUndefined(r2.robustness_value);
-  const benchmarks = sens ? [...sens.benchmarks].sort((a2, b2) => b2.strength - a2.strength) : [];
+  const benchmarks = sens ? [...sens.benchmarks].sort((a2, b2) => compareFloats(b2.strength, a2.strength)) : [];
   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 strongest = benchmarks[0];
-    const value = tip !== null ? strongest !== void 0 ? tip > strongest.strength ? `flips only beyond ${labelOf(meta3, strongest.column)}` : `a cause weaker than ${labelOf(meta3, strongest.column)} could flip it` : `would flip at ${fmt$1(tip)}` : evalue !== void 0 ? `holds (E-value ${fmt$1(evalue)})` : "holds throughout";
-    const scaleNote = strongest !== void 0 ? ` For scale, your strongest known factor (${labelOf(meta3, strongest.column)}) sits at ${fmt$1(strongest.strength)} on this axis.` : "";
+    const value = tip !== null ? strongest !== void 0 ? tip > strongest.strength ? `flips only beyond ${labelOf(meta3, strongest.column)}` : `a cause weaker than ${labelOf(meta3, strongest.column)} could flip it` : `would flip at ${fmt$1(tip, words)}` : evalue !== void 0 ? `holds (E-value ${fmt$1(evalue, words)})` : "holds throughout";
+    const scaleNote = strongest !== void 0 ? ` For scale, your strongest known factor (${labelOf(meta3, strongest.column)}) sits at ${fmt$1(strongest.strength, words)} on this axis.` : "";
     checks.push({
       name: "Hidden cause",
       short: "hidden cause",
@@ -61167,12 +61328,12 @@ function deriveRefute(r2, adj, meta3) {
         const at = atOf(b2.strength);
         return at === null ? [] : [{ at, label: `as strong as ${labelOf(meta3, b2.column)}`, tone: "muted", help: "sensitivity" }];
       });
-      sensVM = { lo: lo2, mid, hi, xTicks: ["none", "", "stronger"], yTicks: [fmt$1(yLo), fmt$1((yLo + yHi) / 2), fmt$1(yHi)], marks };
+      sensVM = { lo: lo2, mid, hi, xTicks: ["none", "", "stronger"], yTicks: [fmt$1(yLo, words), fmt$1((yLo + yHi) / 2, words), fmt$1(yHi, words)], marks };
     }
   }
   return { checks, sens: sensVM };
 }
-function deriveDose(dose, config2, meta3) {
+function deriveDose(dose, config2, meta3, words) {
   const grid = arr(dose.grid);
   const mid = arr(dose.effect);
   const lo2 = eastUiComponents.getSomeorUndefined(dose.lower) ? arr(eastUiComponents.getSomeorUndefined(dose.lower)) : mid.slice();
@@ -61190,17 +61351,17 @@ function deriveDose(dose, config2, meta3) {
     }
   }
   const xi = grid.length ? [0, Math.floor(grid.length / 2), grid.length - 1] : [];
-  const xTicks = xi.map((i) => fmt$1(grid[i]));
+  const xTicks = xi.map((i) => fmt$1(grid[i], words));
   const yLo = Math.min(0, ...lo2), yHi = Math.max(...hi, 0);
-  const yTicks = [fmt$1(yLo), fmt$1((yLo + yHi) / 2), fmt$1(yHi)];
+  const yTicks = [fmt$1(yLo, words), fmt$1((yLo + yHi) / 2, words), fmt$1(yHi, words)];
   const margSteps = marg.slice(1);
   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 marginal = margSteps.slice(0, lastStep + 1).map((v3, i) => ({ label: fmt$1(grid[i + 1], words), value: v3, frac: clamp01(Math.abs(v3) / maxMarg) }));
   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 tradeoff = `Going from ${fmt$1(grid[stepFrom] ?? 0, words)} to ${fmt$1(grid[sweet] ?? 0, words)} adds ${signed(gainToSweet, words)}; the next step adds only ${signed(nextGain, words)}.`;
   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" });
@@ -61217,7 +61378,7 @@ function deriveDose(dose, config2, meta3) {
     marks,
     // Name the feature in the recommendation — a bare "≈ 5.5" doesn't say
     // 5.5 of WHAT.
-    recoLabel: `aim for ${featureLabel} ≈ ${fmt$1(grid[sweet] ?? 0)}${featureUnit ? " " + featureUnit : ""}`,
+    recoLabel: `aim for ${featureLabel} ≈ ${fmt$1(grid[sweet] ?? 0, words)}${featureUnit ? " " + featureUnit : ""}`,
     recoEffect: mid[sweet] ?? 0,
     recoLo: lo2[sweet] ?? 0,
     recoHi: hi[sweet] ?? 0,
@@ -61226,11 +61387,11 @@ function deriveDose(dose, config2, meta3) {
     framing: `A different question from the headline: how ${outcomeLabel} responds as ${featureLabel} itself moves.`
   };
 }
-function relTime(d2, now2) {
+function relTime(d2, now2, words) {
   const days = Math.floor((now2.getTime() - d2.getTime()) / 864e5);
   if (days <= 0) return "today";
   if (days === 1) return "yesterday";
-  if (days < 7) return d2.toLocaleDateString(void 0, { weekday: "short" });
+  if (days < 7) return words.weekday(d2);
   return "last wk";
 }
 const VERDICT_WORD = {
@@ -61240,43 +61401,43 @@ const VERDICT_WORD = {
   non_identifiable_positivity: "no overlap",
   not_estimable: "n/a"
 };
-function deriveJournalRow(row, now2, meta3) {
+function deriveJournalRow(row, now2, meta3, words) {
   const adj = eastUiComponents.getSomeorUndefined(row.adjusted);
   return {
     treatment: labelOf(meta3, row.config.treatment),
     outcome: labelOf(meta3, row.config.outcome),
     confounders: row.config.common_causes.map((c2) => labelOf(meta3, c2)).join(", "),
-    effect: adj !== void 0 ? signed(adj) : signed(row.naive),
+    effect: adj !== void 0 ? signed(adj, words) : signed(row.naive, words),
     verdict: VERDICT_WORD[row.verdict.type],
     verdictTone: VERDICT_TONE[row.verdict.type],
     who: row.committed_by,
-    when: relTime(row.committed_at, now2),
+    when: relTime(row.committed_at, now2, words),
     // The originating preset id (resolved to a label by the surface); `none` for a
     // free-form / pre-presets row.
     preset: row.preset
   };
 }
-function deriveView(config2, ranConfig, cols, result, journal, meta3, dataLen, now2, subject = { one: "record", many: "records" }) {
+function deriveView(config2, ranConfig, cols, result, journal, meta3, dataLen, now2, subject = { one: "record", many: "records" }, words = eastUiComponents.formatters()) {
   var _a2;
   const adj = result ? eastUiComponents.getSomeorUndefined(result.adjusted) : void 0;
   const refutation = result ? eastUiComponents.getSomeorUndefined(result.refutation) : void 0;
   const doseR = result ? eastUiComponents.getSomeorUndefined(result.dose_response) : void 0;
-  const answer = result && adj ? deriveAnswer(ranConfig, result, adj, meta3) : null;
-  const refute = refutation ? deriveRefute(refutation, adj, meta3) : null;
+  const answer = result && adj ? deriveAnswer(ranConfig, result, adj, meta3, words) : null;
+  const refute = refutation ? deriveRefute(refutation, adj, meta3, words) : null;
   const higherBetter = eastUiComponents.getSomeorUndefined((_a2 = colMeta(meta3, ranConfig.outcome)) == null ? void 0 : _a2.higherIsBetter);
   return {
     // 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, subject),
+    spec: deriveSpec(config2, cols, result, meta3, dataLen, subject, words),
     verdict: result ? deriveVerdict(result.verdict) : null,
-    narrative: result ? deriveNarrative(result, answer, refute, higherBetter, subject) : null,
+    narrative: result ? deriveNarrative(result, answer, refute, higherBetter, subject, words) : null,
     answer,
-    refusal: result && !adj ? deriveRefusal(ranConfig, result, meta3, subject) : null,
-    overlap: result ? deriveOverlap(result.overlap) : null,
+    refusal: result && !adj ? deriveRefusal(ranConfig, result, meta3, subject, words) : null,
+    overlap: result ? deriveOverlap(result.overlap, words) : null,
     refute,
-    dose: doseR && doseR.effect.length ? deriveDose(doseR, ranConfig, meta3) : null,
-    journal: journal ? journal.map((r2) => deriveJournalRow(r2, now2, meta3)) : null
+    dose: doseR && doseR.effect.length ? deriveDose(doseR, ranConfig, meta3, words) : null,
+    journal: journal ? journal.map((r2) => deriveJournalRow(r2, now2, meta3, words)) : null
   };
 }
 const DESIGN_HEADLINE = {
@@ -61295,7 +61456,7 @@ function deriveDesignOption(o2) {
     treatedShare: o2.treated_share
   };
 }
-function deriveDesign(d2, result, ranConfig, meta3) {
+function deriveDesign(d2, result, ranConfig, meta3, words = eastUiComponents.formatters()) {
   const basis = d2.basis.type;
   const outcome = ranConfig.outcome;
   const unit2 = unitOf(meta3, outcome);
@@ -61327,9 +61488,9 @@ function deriveDesign(d2, result, ranConfig, meta3) {
     }
     return bi;
   };
-  const xTicks = len ? [String(ns[0]), String(ns[Math.floor((len - 1) / 2)]), String(ns[len - 1])] : [];
+  const xTicks = len ? [words.number(ns[0]), words.number(ns[Math.floor((len - 1) / 2)]), words.number(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" });
+  if (len) marks.push({ at: nearest(primary.nTotal), label: `target ${words.percent(d2.target_power)}`, tone: "pos", help: "validate_power" });
   const cp = eastUiComponents.getSomeorUndefined(d2.current_power);
   if (cp !== void 0 && len) {
     const curN = result ? Number(result.n_total) : 0;
@@ -61337,7 +61498,7 @@ function deriveDesign(d2, result, ranConfig, meta3) {
       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)}%`,
+        label: offScale ? `you’re here · ${words.percent(cp)} (off-scale)` : `you’re here ${words.percent(cp)}`,
         tone: "muted",
         help: "validate_power"
       });
@@ -61351,13 +61512,204 @@ function deriveDesign(d2, result, ranConfig, meta3) {
     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)}%`,
+    targetLabel: `${signed(d2.target_effect, words)}${unit2 ? ` ${unit2}` : ""}`,
+    targetPctLabel: words.percent(d2.target_power),
     holdback: basis === "create_control",
     showOverlap: basis === "restrict_to_overlap",
     faint
   };
 }
+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 } : {} };
+}
+function useMeasuredWidth() {
+  const ref = React.useRef(null);
+  const [w2, setW] = React.useState(0);
+  React.useLayoutEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const update2 = () => setW(el.clientWidth);
+    update2();
+    const ro = new ResizeObserver(update2);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, []);
+  return [ref, w2];
+}
+function useChartTheme() {
+  const system = react.useChakraContext();
+  const tok = (k2, fallback) => system.token(k2, fallback);
+  const tones = {
+    neg: tok("colors.fg.danger", "#b85a4a"),
+    pos: tok("colors.fg.success", "#2f7a5b"),
+    warn: tok("colors.fg.warning", "#b8862d"),
+    muted: tok("colors.fg.muted", "#6b8080"),
+    brand: tok("colors.brand.solid", "#3a7780")
+  };
+  return {
+    mono: tok("fonts.mono", '"JetBrains Mono", ui-monospace, monospace'),
+    body: tok("fonts.body", "system-ui, -apple-system, sans-serif"),
+    ink: tok("colors.fg", "#111b22"),
+    muted: tones.muted,
+    faint: tok("colors.fg.subtle", "#9bb0b0"),
+    rule: tok("colors.border.subtle", "#e2e8e8"),
+    ruleStrong: tok("colors.border.strong", "#cbd5d5"),
+    surface: tok("colors.bg.surface", "#ffffff"),
+    tone: (t4) => tones[t4] ?? tones.brand,
+    labelSize: 10,
+    titleSize: 11,
+    lineWidth: 1.8,
+    barWidth: 2.5,
+    dotRadius: 2.6,
+    scatterRadius: 3.4,
+    areaOpacity: 0.16
+  };
+}
+const niceCeil = (v3) => {
+  if (v3 <= 1e-9) return 0;
+  const mag = Math.pow(10, Math.floor(Math.log10(v3)));
+  const n2 = v3 / mag;
+  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, rowHelp }) {
+  const t4 = useChartTheme();
+  const words = eastUiComponents.useFormatters();
+  const [ref, w2] = useMeasuredWidth();
+  const n2 = rows.length;
+  const hPx = height2 ?? 26 + n2 * 38;
+  const padL = 124, padR = 46, padT = 20, padB = 30;
+  const innerW = Math.max(0, w2 - padL - padR);
+  const innerH = hPx - padT - padB;
+  const x2 = createLinearScale({ domain: [min4, max5], range: [0, innerW] });
+  const rowH = innerH / Math.max(1, n2);
+  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: 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);
+      return /* @__PURE__ */ jsxRuntime.jsxs(Group, { top: cy, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: x2(r2.lo), y: 0 }, to: { x: x2(r2.hi), y: 0 }, stroke: col, strokeWidth: t4.barWidth, strokeOpacity: 0.9, strokeLinecap: "round" }),
+        /* @__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(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(r2.est, words) })
+      ] }, 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: 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: anchorAt(tk), style: svgText(t4.labelSize, t4.muted, t4.mono), children: signed(tk, words) })
+    ] }, `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 = [], xTickWords = false, yTicks = [], zero: zero2, tone: toneName, marks = [], height: height2, yFormat = "signed" }) {
+  const t4 = useChartTheme();
+  const words = eastUiComponents.useFormatters();
+  const [ref, w2] = useMeasuredWidth();
+  const hPx = height2 ?? 100;
+  const col = t4.tone(toneName ?? "brand");
+  const padL = yTicks.length ? 52 : 6;
+  const padR = 12;
+  const padT = marks.length ? 22 : 8;
+  const padB = xTicks.length ? 22 : 12;
+  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 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 yfmt = (v3) => yFormat === "percent" ? words.percent(v3 / 100) : signed(v3, words);
+  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: [
+      /* @__PURE__ */ jsxRuntime.jsx("text", { x: -8, y: 10, textAnchor: "end", style: svgText(t4.labelSize, t4.muted, t4.mono), children: yLabels[0] }),
+      /* @__PURE__ */ jsxRuntime.jsx("text", { x: -8, y: innerH / 2 + 3, textAnchor: "end", style: svgText(t4.labelSize, t4.muted, t4.mono), children: yLabels[1] }),
+      /* @__PURE__ */ jsxRuntime.jsx("text", { x: -8, y: innerH - 1, textAnchor: "end", style: svgText(t4.labelSize, t4.muted, t4.mono), children: yLabels[2] })
+    ] }),
+    zero2 != null && /* @__PURE__ */ jsxRuntime.jsx(Line, { from: { x: 0, y: yScale(zero2) }, to: { x: innerW, y: yScale(zero2) }, stroke: t4.muted, strokeWidth: 1, strokeDasharray: "3 2" }),
+    /* @__PURE__ */ jsxRuntime.jsx(Area, { data: data4, x: (d2) => xScale(d2.i), y0: (d2) => yScale(d2.lo), y1: (d2) => yScale(d2.hi), curve: monotoneX, fill: col, fillOpacity: t4.areaOpacity, stroke: "transparent" }),
+    /* @__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(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.5 + 8;
+      const labX = atEnd ? -labW - 5 : atStart ? 5 : -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(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 }),
+    xTicks.map((tk, i) => {
+      const word = xTickWords;
+      return /* @__PURE__ */ jsxRuntime.jsx("text", { x: innerW * i / Math.max(1, xTicks.length - 1), y: innerH + 14, textAnchor: i === 0 ? "start" : i === xTicks.length - 1 ? "end" : "middle", style: svgText(word ? 9 : t4.labelSize, word ? t4.faint : t4.muted, word ? t4.body : t4.mono), children: tk }, `x${i}`);
+    })
+  ] }) }) });
+}
+function OverlapHistogram({ treated, control, domain = [0, 1], supportLabel, positivityOk, height: height2 }) {
+  const t4 = useChartTheme();
+  const words = eastUiComponents.useFormatters();
+  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$1(tk, words) }, `x${i}`))
+  ] }) }) });
+}
 const SUBJECT_DEFAULT = { one: "record", many: "records" };
 const AUTORUN_MAX_ROWS = 5e4;
 const TONE_TOKEN = {
@@ -61385,7 +61737,7 @@ function kindOfTypeValue(t4) {
   }
 }
 function useColumns(workspace, source) {
-  const types = source ? getBindingTypes(workspace, source) : void 0;
+  const types = getBindingTypes(workspace, source);
   return React.useMemo(() => {
     const st = types == null ? void 0 : types.sourceType;
     if (!st || st.type !== "Array") return { columns: [], rowArrayType: null };
@@ -61397,35 +61749,9 @@ function useColumns(workspace, source) {
     };
   }, [types == null ? void 0 : types.sourceType]);
 }
-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 east.isEastSet(ov) ? ov.has(v3) : true;
-      case "notIn":
-        return east.isEastSet(ov) ? !ov.has(v3) : true;
-      default:
-        return true;
-    }
-  });
+function inPopulation(row, population) {
+  return population.every((p2) => eastUi.slicePredicateMatches(p2, row));
 }
-const num = (x2) => typeof x2 === "number" ? x2 : typeof x2 === "bigint" ? Number(x2) : null;
 function Cap({ children: children2, help }) {
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "caption.eyebrow", fontSize: "9px", mb: "2.5", children: help ? /* @__PURE__ */ jsxRuntime.jsx(Help, { id: help, children: children2 }) : children2 }),
@@ -61538,7 +61864,7 @@ function LoadingSkeleton() {
     ] })
   ] });
 }
-const experimentValueEqual = east.equalFor(internal$1.Experiment.Component.schema);
+const experimentValueEqual = east.equivalentFor(internal$1.Experiment.Component.schema);
 const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }) {
   var _a2, _b2, _c2;
   const v3 = value;
@@ -61548,6 +61874,7 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
   const bs = react.useSlotRecipe({ key: "barStrip" })({});
   const statusR = react.useSlotRecipe({ key: "status" });
   const es = react.useSlotRecipe({ key: "eyebrowRow" })({});
+  const words = eastUiComponents.useFormatters();
   const workspace = getReactiveDatasetCache().getConfig().workspace ?? "";
   const data4 = useBindingValue(v3.data);
   const journalBind = useBindingValue(v3.journal.type === "some" ? v3.journal.value : null);
@@ -61595,7 +61922,7 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
   const population = localPop;
   const filteredRows = React.useMemo(() => {
     if (!data4.value) return null;
-    return population.length ? data4.value.filter((r2) => rowMatchesAll(r2, population)) : data4.value;
+    return population.length ? data4.value.filter((r2) => inPopulation(r2, population)) : data4.value;
   }, [data4.value, population]);
   const fields = React.useMemo(
     () => columns.filter((c2) => c2.kind !== "other").map((c2) => {
@@ -61697,8 +62024,8 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
   }, [ranConfig, config2, meta3, subject]);
   const view = React.useMemo(() => {
     if (!config2) return null;
-    return deriveView(config2, ranConfig ?? config2, columns, shownResult, journalBind.value, meta3, nRows, now2, subject);
-  }, [config2, ranConfig, columns, shownResult, journalBind.value, meta3, nRows, now2, subject]);
+    return deriveView(config2, ranConfig ?? config2, columns, shownResult, journalBind.value, meta3, nRows, now2, subject, words);
+  }, [config2, ranConfig, columns, shownResult, journalBind.value, meta3, nRows, now2, subject, words]);
   const designConfigValue = React.useMemo(() => ({
     alpha: east.none,
     target_power: east.none,
@@ -61711,15 +62038,15 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
     var _a3;
     if (tab !== "validate" || !hasDesign || design.pending || precomputedDesign !== null) return;
     if (!filteredRows || !config2 || !shownResult) return;
-    if (((_a3 = designSnapRef.current) == null ? void 0 : _a3.result) === shownResult) return;
+    if (Object.is((_a3 = designSnapRef.current) == null ? void 0 : _a3.result, shownResult)) return;
     designSnapRef.current = { result: shownResult, config: ranConfig ?? config2 };
     design.call(filteredRows, ranConfig ?? config2, shownResult, designConfigValue);
   }, [tab, hasDesign, precomputedDesign, filteredRows, config2, ranConfig, shownResult, design, designConfigValue]);
   const vmDesign = React.useMemo(() => {
-    if (precomputedDesign !== null && shownResult !== null && config2) return deriveDesign(precomputedDesign, shownResult, ranConfig ?? config2, meta3);
-    return design.result && designSnapRef.current ? deriveDesign(design.result, designSnapRef.current.result, designSnapRef.current.config, meta3) : null;
-  }, [precomputedDesign, shownResult, config2, ranConfig, design.result, meta3]);
-  const designFresh = precomputedDesign !== null && shownResult !== null || design.result !== null && ((_b2 = designSnapRef.current) == null ? void 0 : _b2.result) === shownResult && !design.pending;
+    if (precomputedDesign !== null && shownResult !== null && config2) return deriveDesign(precomputedDesign, shownResult, ranConfig ?? config2, meta3, words);
+    return design.result && designSnapRef.current ? deriveDesign(design.result, designSnapRef.current.result, designSnapRef.current.config, meta3, words) : null;
+  }, [precomputedDesign, shownResult, config2, ranConfig, design.result, meta3, words]);
+  const designFresh = precomputedDesign !== null && shownResult !== null || design.result !== null && Object.is((_b2 = designSnapRef.current) == null ? void 0 : _b2.result, shownResult) && !design.pending;
   if (!config2 || !view) {
     const failed2 = experiment.status === "failed";
     const noConfigs = !configsBind.error && configs.length === 0;
@@ -61787,7 +62114,7 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
       readonly && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: badge({ variant: "plain", size: "sm" }), textTransform: "none", letterSpacing: "normal", children: "View only" }),
       /* @__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: stale ? `${nRows} rows` : vs.dataLabel })
+        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: dataStatus.label, children: stale ? `${words.number(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 }),
@@ -61820,7 +62147,7 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
             "add another"
           ] }) })
         ] }) }),
-        /* @__PURE__ */ jsxRuntime.jsx(Step, { n: 4, title: `Which ${subject.many}?`, help: "step_population", children: /* @__PURE__ */ jsxRuntime.jsx(FilterRail, { fields, population, onChange: editPopulation, chip, button, readonly, subjectMany: subject.many }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(Step, { n: 4, title: `Which ${subject.many}?`, help: "step_population", children: /* @__PURE__ */ jsxRuntime.jsx(FilterRail, { fields, population, onChange: editPopulation, chip, button, readonly, subjectMany: subject.many, words }) }),
         /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "details", borderTopWidth: "1px", borderColor: "border.subtle", children: [
           /* @__PURE__ */ jsxRuntime.jsxs(
             react.Box,
@@ -61938,10 +62265,11 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
               subjectMany: subject.many,
               higherBetter,
               badge,
-              barList
+              barList,
+              words
             }
           ),
-          activeTab === "answer" && !a2 && ref && /* @__PURE__ */ jsxRuntime.jsx(RefusalZone, { refusal: ref, overlap: ov, naiveValue: (shownResult == null ? void 0 : shownResult.naive) ?? 0, outcome: vs.outcomeLabel }),
+          activeTab === "answer" && !a2 && ref && /* @__PURE__ */ jsxRuntime.jsx(RefusalZone, { refusal: ref, overlap: ov, naiveValue: (shownResult == null ? void 0 : shownResult.naive) ?? 0, outcome: vs.outcomeLabel, words }),
           activeTab === "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) => {
@@ -61969,6 +62297,7 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
                   zero: 0,
                   tone: "brand",
                   xTicks: vr.sens.xTicks,
+                  xTickWords: true,
                   yTicks: vr.sens.yTicks,
                   marks: vr.sens.marks,
                   height: vr.sens.marks.length ? 148 : 132
@@ -62014,13 +62343,13 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
                 /* @__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.jsx(react.Text, { textStyle: "mono-kpi", fontFamily: "heading", color: "brand.solid", children: signed(vd.recoEffect, words) }),
                     /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: [
                       vd.outcome,
                       " · ",
-                      signed(vd.recoLo),
+                      signed(vd.recoLo, words),
                       " … ",
-                      signed(vd.recoHi)
+                      signed(vd.recoHi, words)
                     ] })
                   ] })
                 ] }),
@@ -62032,7 +62361,7 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
                   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) }))) })
+                /* @__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, words) }))) })
               ] })
             ] })
           ] }),
@@ -62050,7 +62379,7 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
               " tab for why)."
             ] })
           ] }),
-          activeTab === "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 }) : !hasDesign && precomputedDesign === null ? /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
+          activeTab === "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, words }) : !hasDesign && precomputedDesign === null ? /* @__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: "No trial recipe for this question" })
@@ -62067,7 +62396,7 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
       /* @__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: /* @__PURE__ */ jsxRuntime.jsx(Help, { id: "journal", children: "Committed experiments" }) }),
         /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: es.meta, children: /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { as: "span", children: [
-          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.default", fontWeight: "semibold", children: journal.length }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.default", fontWeight: "semibold", children: words.number(journal.length) }),
           " on record",
           journal.length > 50 ? " · showing newest 50" : ""
         ] }) })
@@ -62109,7 +62438,7 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
     ] })
   ] }) });
 }, (prev2, next2) => experimentValueEqual(prev2.value, next2.value) && prev2.storageKey === next2.storageKey);
-function AnswerNumeric({ a: a2, verdict, narrative, checks, onGoTrust, subjectMany, higherBetter, badge, barList }) {
+function AnswerNumeric({ a: a2, verdict, narrative, checks, onGoTrust, subjectMany, higherBetter, badge, barList, words }) {
   const dirUp = a2.effect > 0;
   const statusWord = higherBetter === void 0 ? dirUp ? "Higher" : "Lower" : dirUp === higherBetter ? "Better" : "Worse";
   const lowerWord = a2.naive < 0 ? "lower" : "higher";
@@ -62124,7 +62453,7 @@ function AnswerNumeric({ a: a2, verdict, narrative, checks, onGoTrust, subjectMa
         /* @__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.jsxs(Help, { id: "answer_effect", children: [
-            signed(a2.effect),
+            signed(a2.effect, words),
             a2.unit ? /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { as: "span", fontSize: "16px", color: "fg.muted", children: [
               " ",
               a2.unit
@@ -62132,9 +62461,9 @@ function AnswerNumeric({ a: a2, verdict, narrative, checks, onGoTrust, subjectMa
           ] }) }),
           /* @__PURE__ */ jsxRuntime.jsx(react.Text, { textStyle: "mono.sm", color: "fg.muted", children: /* @__PURE__ */ jsxRuntime.jsxs(Help, { id: "answer_ci", children: [
             "likely between ",
-            signed(a2.lo),
+            signed(a2.lo, words),
             " and ",
-            signed(a2.hi)
+            signed(a2.hi, words)
           ] }) })
         ] })
       ] }),
@@ -62198,7 +62527,7 @@ function AnswerNumeric({ a: a2, verdict, narrative, checks, onGoTrust, subjectMa
         " on ",
         /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "semibold", children: a2.outcome }),
         " (",
-        signed(a2.naive),
+        signed(a2.naive, words),
         ") — but they also differ most on ",
         /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "semibold", children: top.label }),
         " (",
@@ -62257,13 +62586,13 @@ function AnswerNumeric({ a: a2, verdict, narrative, checks, onGoTrust, subjectMa
       /* @__PURE__ */ jsxRuntime.jsx(react.Box, { px: "3.5", pb: "3.5", py: "0.5", maxH: "208px", overflowY: "auto", children: barList(a2.balance.map((b2) => ({ label: b2.label, 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, subjectMany], [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) }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.default", fontWeight: "semibold", children: words.number(n2) }),
       " ",
       label
     ] }, i)) }) })
   ] });
 }
-function RefusalZone({ refusal, overlap, naiveValue, outcome }) {
+function RefusalZone({ refusal, overlap, naiveValue, outcome, words }) {
   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" } }),
@@ -62286,11 +62615,11 @@ function RefusalZone({ refusal, overlap, naiveValue, outcome }) {
       "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) })
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", color: "fg.muted", children: signed(naiveValue, words) })
     ] })
   ] });
 }
-function ValidatePanel({ vm, barList }) {
+function ValidatePanel({ vm, barList, words }) {
   const stat = react.useSlotRecipe({ key: "stat" })({ size: "lg" });
   const meter = react.useSlotRecipe({ key: "segmentedMeter" })({});
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { p: "4.5", children: [
@@ -62298,7 +62627,7 @@ function ValidatePanel({ vm, barList }) {
     /* @__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() })
+        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: words.number(vm.primary.nTotal) })
       ] }),
       /* @__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" }) }),
@@ -62310,7 +62639,7 @@ function ValidatePanel({ vm, barList }) {
           /* @__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() }),
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", css: meter.valueText, children: words.number(vm.primary.nTreated) }),
               " ",
               vm.holdback ? "treated" : "get it"
             ] })
@@ -62318,7 +62647,7 @@ function ValidatePanel({ vm, barList }) {
           /* @__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() }),
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", css: meter.valueText, children: words.number(vm.primary.nControl) }),
               " ",
               vm.holdback ? "held back" : "left alone"
             ] })
@@ -62351,16 +62680,16 @@ function ValidatePanel({ vm, barList }) {
     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(),
+      words.number(o2.nTotal),
       " total (",
-      o2.nTreated.toLocaleString(),
+      words.number(o2.nTreated),
       " / ",
-      o2.nControl.toLocaleString(),
+      words.number(o2.nControl),
       ")"
     ] }, i)) })
   ] });
 }
-function FilterRail({ fields, population, onChange: onChange2, chip, button, readonly, subjectMany }) {
+function FilterRail({ fields, population, onChange: onChange2, chip, button, readonly, subjectMany, words }) {
   const [open, setOpen] = React.useState(null);
   const replaceAt = (i, p2) => onChange2(population.map((f2, j2) => j2 === i ? p2 : f2));
   const removeAt = (i) => onChange2(population.filter((_2, j2) => j2 !== i));
@@ -62369,7 +62698,7 @@ function FilterRail({ fields, population, onChange: onChange2, chip, button, rea
     return /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", flexWrap: "wrap", gap: "1.5", alignItems: "center", children: population.length === 0 ? /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: chip({ tone: "plain", numeric: true, shape: "rounded" }), children: [
       "all ",
       subjectMany
-    ] }) : population.map((pred, i) => /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: chip({ tone: "brand", numeric: true, shape: "rounded" }), flexShrink: 0, children: /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", whiteSpace: "nowrap", children: eastUiComponents.formatPredicate(pred) }) }, i)) });
+    ] }) : population.map((pred, i) => /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: chip({ tone: "brand", numeric: true, shape: "rounded" }), flexShrink: 0, children: /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", whiteSpace: "nowrap", children: eastUiComponents.formatPredicate(pred, words) }) }, i)) });
   }
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexWrap: "wrap", gap: "1.5", alignItems: "center", children: [
     population.map((pred, i) => /* @__PURE__ */ jsxRuntime.jsx(
@@ -62383,7 +62712,7 @@ function FilterRail({ fields, population, onChange: onChange2, chip, button, rea
         ] }),
         footActions: done,
         trigger: /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: chip({ tone: "brand", numeric: true, shape: "rounded" }), cursor: "pointer", flexShrink: 0, children: [
-          /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", whiteSpace: "nowrap", children: eastUiComponents.formatPredicate(pred) }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", whiteSpace: "nowrap", children: eastUiComponents.formatPredicate(pred, words) }),
           /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "button", display: "inline-flex", alignItems: "center", cursor: "pointer", color: "brand.fg", flexShrink: "0", fontSize: "10px", onClick: (e3) => {
             e3.stopPropagation();
             removeAt(i);
@@ -62509,20 +62838,8 @@ function viewFor(binding) {
   const patch = binding.patch.type === "some" ? binding.patch.value : void 0;
   return defaultBindRuntime.buildBindHandle(types.sourceType, source, patch, binding.mode.type);
 }
-function stableStringify(v3) {
-  return JSON.stringify(v3, (_k, x2) => {
-    if (typeof x2 === "bigint") return `${x2}n`;
-    if (x2 instanceof Date) return x2.toISOString();
-    if (east.isEastSet(x2)) return [...x2].sort();
-    if (east.isEastDict(x2)) return [...x2.entries()].sort((a2, b2) => String(a2[0]).localeCompare(String(b2[0])));
-    return x2;
-  });
-}
-function hashString2(s2) {
-  let h2 = 5381;
-  for (let i = 0; i < s2.length; i++) h2 = (h2 << 5) + h2 + s2.charCodeAt(i) | 0;
-  return (h2 >>> 0).toString(36);
-}
+const printDescriptors = east.printFor(east.StructType({ decisions: east.ArrayType(internal$1.DiffBindingType), judgements: internal$1.DiffBindingType }));
+const printTypeValue = east.printFor(east.EastTypeValueType);
 function readSelectionAt(selectionKey) {
   platform.StateRuntime.trackKey(selectionKey);
   const bytes = platform.StateRuntime.getStore().read(selectionKey);
@@ -62564,16 +62881,6 @@ function removeFromOwningView(decisions, caseId) {
   }
 }
 const decisionHandleCache = /* @__PURE__ */ new Map();
-function typeToken(tv) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  return JSON.stringify(tv, (_k, v3) => {
-    if (typeof v3 === "object" && v3 !== null) {
-      if (seen.has(v3)) return "<cyc>";
-      seen.add(v3);
-    }
-    return typeof v3 === "bigint" ? `${v3}n` : v3;
-  });
-}
 function compileDecisionMethods(constraintType, decisions, judgements, selectionKey) {
   const platform$1 = platform.getRegisteredPlatformImplementations();
   const c2 = east.fromEastTypeValue(constraintType);
@@ -62641,7 +62948,7 @@ function buildDecisionHandle(decisions, judgements, constraintType) {
     const at = (j2) => j2.resolvedAt.type === "some" ? j2.resolvedAt.value.getTime() : 0;
     return entries.sort((a2, b2) => at(b2) - at(a2));
   };
-  const cacheKey = `${hashString2(stableStringify({ decisions, judgements }))}|${typeToken(cType)}`;
+  const cacheKey = `${printDescriptors({ decisions, judgements })}|${printTypeValue(east.canonicalTypeValue(cType))}`;
   let methods = decisionHandleCache.get(cacheKey);
   if (methods === void 0) {
     methods = compileDecisionMethods(cType, decisions, judgements, selectionKey);
@@ -62831,91 +63138,71 @@ const OP_WORDS = {
   notIn: "not in",
   is: "is"
 };
-function formatScalar(v3) {
-  if (v3 instanceof Date) {
-    return `${v3.toLocaleString("en", { month: "short" })} ${v3.getDate()}`;
-  }
-  if (east.isEastSet(v3)) {
-    return `{${[...v3].map(formatScalar).join(", ")}}`;
+const PRINTERS = /* @__PURE__ */ new WeakMap();
+function printerOf(contract) {
+  let printer = PRINTERS.get(contract);
+  if (printer === void 0) {
+    const context = /* @__PURE__ */ new Map();
+    east.printFor(contract.type, context);
+    printer = (type) => east.printFor(type, context);
+    PRINTERS.set(contract, printer);
   }
-  if (v3 !== null && typeof v3 === "object" && !v3.type) {
-    return Object.entries(v3).map(([k2, x2]) => `${k2} ${formatScalar(x2)}`).join(" · ");
-  }
-  return String(v3);
+  return printer;
 }
-function formatConstraint(constraint, payloadType, levers) {
-  var _a2, _b2;
-  const c2 = constraint;
-  const lever = ((_a2 = levers == null ? void 0 : levers.find((l2) => l2.case === c2.type)) == null ? void 0 : _a2.label) ?? c2.type;
-  if ((payloadType == null ? void 0 : payloadType.type) === "Variant") {
-    const op = c2.value;
-    const word = OP_WORDS[op.type] ?? op.type;
-    const opType = (_b2 = payloadType.cases) == null ? void 0 : _b2[op.type];
-    if ((opType == null ? void 0 : opType.type) === "Struct" && op.value !== null && typeof op.value === "object") {
-      const r2 = op.value;
-      if ("min" in r2 && "max" in r2) {
-        return { lever, op: word, value: `${formatScalar(r2.min)} – ${formatScalar(r2.max)}` };
-      }
+function formatValue(value, type, words, print) {
+  switch (type.type) {
+    case "DateTime":
+      return words.monthDay(value);
+    case "Float":
+      return words.float(value);
+    case "String":
+      return value;
+    case "Set": {
+      const member = type.value;
+      return `{${[...value].map((m2) => formatValue(m2, member, words, print)).join(", ")}}`;
     }
-    return { lever, op: word, value: formatScalar(op.value) };
-  }
-  return { lever, op: "·", value: formatScalar(c2.value) };
-}
-const PRIMITIVES = /* @__PURE__ */ new Set(["String", "Integer", "Float", "DateTime", "Boolean"]);
-function normalizeTypeValue(tv) {
-  var _a2;
-  const n2 = tv;
-  if (n2.cases !== void 0 || n2.fields !== void 0) {
-    const out = { type: n2.type };
-    if (n2.cases) out.cases = Object.fromEntries(Object.entries(n2.cases).map(([k2, v3]) => [k2, normalizeTypeValue(v3)]));
-    if (n2.fields) out.fields = Object.fromEntries(Object.entries(n2.fields).map(([k2, v3]) => [k2, normalizeTypeValue(v3)]));
-    if (n2.key) out.key = normalizeTypeValue(n2.key);
-    if (n2.value !== void 0 && (n2.type === "Array" || n2.type === "Dict")) out.value = normalizeTypeValue(n2.value);
-    return out;
-  }
-  switch (n2.type) {
     case "Struct":
-      return { type: "Struct", fields: Object.fromEntries(n2.value.map((f2) => [f2.name, normalizeTypeValue(f2.type)])) };
-    case "Variant":
-      return { type: "Variant", cases: Object.fromEntries(n2.value.map((f2) => [f2.name, normalizeTypeValue(f2.type)])) };
-    case "Array":
-      return { type: "Array", value: normalizeTypeValue(n2.value) };
-    case "Dict": {
-      const d2 = n2.value;
-      return { type: "Dict", key: normalizeTypeValue(d2.key), value: normalizeTypeValue(d2.value) };
-    }
-    case "Recursive": {
-      const w2 = n2.value;
-      if ((w2 == null ? void 0 : w2.type) === "wrapper" && ((_a2 = w2.value) == null ? void 0 : _a2.inner)) return normalizeTypeValue(w2.value.inner);
-      return { type: n2.type };
-    }
+      return type.value.map((f2) => `${f2.name} ${formatValue(value[f2.name], f2.type, words, print)}`).join(" · ");
     default:
-      return { type: n2.type };
+      return print(type)(value);
   }
 }
-function emptyFor(node2) {
-  switch (node2.type) {
-    case "Integer":
-      return 0n;
-    case "Float":
-      return 0;
-    case "DateTime":
-      return /* @__PURE__ */ new Date();
-    case "Boolean":
-      return false;
-    case "String":
-      return "";
-    case "Struct":
-      return Object.fromEntries(Object.entries(node2.fields ?? {}).map(([k2, f2]) => [k2, emptyFor(f2)]));
-    default:
-      return null;
+function formatConstraint(constraint, contract, levers, words = eastUiComponents.formatters()) {
+  var _a2;
+  const lever = ((_a2 = levers == null ? void 0 : levers.find((l2) => l2.case === constraint.type)) == null ? void 0 : _a2.label) ?? constraint.type;
+  const payload = contract == null ? void 0 : contract.payloads.get(constraint.type);
+  if (contract === void 0 || payload === void 0) return { lever, op: "·", value: "" };
+  const print = printerOf(contract);
+  if (payload.type === "Variant") {
+    const op = constraint.value;
+    const word = OP_WORDS[op.type] ?? op.type;
+    const opType = payload.value.find((c2) => c2.name === op.type).type;
+    if (opType.type === "Struct") {
+      const fields = opType.value;
+      const min4 = fields.find((f2) => f2.name === "min");
+      const max5 = fields.find((f2) => f2.name === "max");
+      if (min4 !== void 0 && max5 !== void 0) {
+        const range = op.value;
+        return { lever, op: word, value: `${formatValue(range.min, min4.type, words, print)} – ${formatValue(range.max, max5.type, words, print)}` };
+      }
+    }
+    return { lever, op: word, value: formatValue(op.value, opType, words, print) };
   }
+  return { lever, op: "·", value: formatValue(constraint.value, payload, words, print) };
 }
-function leverPayloadEditable(node2) {
-  if (!node2) return false;
-  if (PRIMITIVES.has(node2.type)) return true;
-  if (node2.type === "Struct") return Object.values(node2.fields ?? {}).every((f2) => PRIMITIVES.has(f2.type));
-  if (node2.type === "Variant") return Object.values(node2.cases ?? {}).every((c2) => PRIMITIVES.has(c2.type) || c2.type === "Struct" && Object.values(c2.fields ?? {}).every((f2) => PRIMITIVES.has(f2.type)));
+const PRIMITIVES = /* @__PURE__ */ new Set(["String", "Integer", "Float", "DateTime", "Boolean"]);
+const NULL_TYPE = east.toEastTypeValue(east.NullType);
+function emptyFor(type) {
+  if (type.type === "DateTime") return /* @__PURE__ */ new Date();
+  if (type.type === "Struct") return Object.fromEntries(type.value.map((f2) => [f2.name, emptyFor(f2.type)]));
+  return east.defaultValue(type);
+}
+function leverPayloadEditable(payload) {
+  if (payload === void 0) return false;
+  const primitive = (t4) => PRIMITIVES.has(t4.type);
+  const structOfPrimitives = (t4) => t4.type === "Struct" && t4.value.every((f2) => primitive(f2.type));
+  if (primitive(payload) || structOfPrimitives(payload)) return true;
+  if (payload.type === "Variant") return payload.value.every((c2) => primitive(c2.type) || structOfPrimitives(c2.type));
   return false;
 }
 const inputStyle = east.some({ size: east.some(east.variant("sm", null)) });
@@ -62923,17 +63210,17 @@ function LeverEditor({ leverCase, payload, onInject }) {
   var _a2;
   const button = react.useRecipe({ key: "button" });
   const isOpVariant = payload.type === "Variant";
-  const ops = React.useMemo(() => isOpVariant ? Object.keys(payload.cases ?? {}) : [], [isOpVariant, payload]);
+  const ops = React.useMemo(() => payload.type === "Variant" ? payload.value.map((c2) => c2.name) : [], [payload]);
   const [opTag, setOpTag] = React.useState(ops[0] ?? "");
-  const active = isOpVariant ? ((_a2 = payload.cases) == null ? void 0 : _a2[opTag]) ?? { type: "Null" } : payload;
+  const active = payload.type === "Variant" ? ((_a2 = payload.value.find((c2) => c2.name === opTag)) == null ? void 0 : _a2.type) ?? NULL_TYPE : payload;
   const valRef = React.useRef(emptyFor(active));
   const keyRef = React.useRef(`${leverCase}:${opTag}`);
   if (keyRef.current !== `${leverCase}:${opTag}`) {
     keyRef.current = `${leverCase}:${opTag}`;
     valRef.current = emptyFor(active);
   }
-  const primitiveInput = (node2, key, get3, set3) => {
-    switch (node2.type) {
+  const primitiveInput = (type, key, get3, set3) => {
+    switch (type.type) {
       case "Integer":
         return /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraIntegerInput, { value: { value: get3(), onChange: east.some(set3), style: inputStyle } }, key);
       case "Float":
@@ -62946,7 +63233,7 @@ function LeverEditor({ leverCase, payload, onInject }) {
           {
             ariaLabel: key,
             value: {
-              value: east.some(String(get3())),
+              value: east.some(get3() === true ? "true" : "false"),
               items: [{ value: "true", label: "true", disabled: east.none }, { value: "false", label: "false", disabled: east.none }],
               placeholder: east.none,
               multiple: east.none,
@@ -62959,17 +63246,19 @@ function LeverEditor({ leverCase, payload, onInject }) {
           },
           key
         );
+      case "String":
+        return /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraStringInput, { value: { value: get3(), onChange: east.some(set3), style: inputStyle } }, key);
       default:
-        return /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraStringInput, { value: { value: String(get3() ?? ""), onChange: east.some(set3), style: inputStyle } }, key);
+        return null;
     }
   };
   const valueControls = React.useMemo(() => {
     const k2 = keyRef.current;
     if (active.type === "Struct") {
-      return Object.entries(active.fields ?? {}).map(([field, node2]) => /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "6px", minW: 0, children: [
+      return active.value.map(({ name: field, type }) => /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "6px", minW: 0, children: [
         /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", textStyle: "caption.eyebrow", color: "fg.subtle", flexShrink: 0, children: field }),
         primitiveInput(
-          node2,
+          type,
           `${k2}.${field}.in`,
           () => valRef.current[field],
           (v3) => {
@@ -63025,11 +63314,12 @@ function LeverEditor({ leverCase, payload, onInject }) {
     }
   );
 }
-function fmt(d2, n2, showSign = false) {
-  return eastUiComponents.formatTick(n2, eastUiComponents.getSomeorUndefined(d2.format), showSign);
+function fmt(words, d2, n2, showSign = false) {
+  return words.value(n2, eastUiComponents.getSomeorUndefined(d2.format), showSign);
 }
 const caption = { textStyle: "caption.eyebrow", color: "fg.muted" };
 const EvidenceFacet = React.memo(function EvidenceFacet2({ decision, children: children2 }) {
+  const words = eastUiComponents.useFormatters();
   const stakes = eastUiComponents.getSomeorUndefined(decision.stakes);
   const downside = eastUiComponents.getSomeorUndefined(decision.downside);
   const confidence = eastUiComponents.getSomeorUndefined(decision.confidence);
@@ -63045,15 +63335,12 @@ const EvidenceFacet = React.memo(function EvidenceFacet2({ decision, children: c
         ] }),
         downside !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
           "if wrong ",
-          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontWeight: "semibold", color: "fg.danger", children: fmt(decision, downside, true) }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontWeight: "semibold", color: "fg.danger", children: fmt(words, decision, downside, true) }),
           " · "
         ] }),
         confidence !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
           "confidence ",
-          /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { as: "span", fontFamily: "mono", fontWeight: "semibold", children: [
-            Math.round(confidence * 100),
-            "%"
-          ] })
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontWeight: "semibold", children: words.percent(confidence) })
         ] })
       ] })
     ] }),
@@ -63069,8 +63356,9 @@ const EvidenceFacet = React.memo(function EvidenceFacet2({ decision, children: c
     children2
   ] });
 });
+const compareValues$1 = east.compareFor(east.FloatType);
 function rankOptions(d2) {
-  const alternatives = [...d2.alternatives].sort((a2, b2) => b2.value - a2.value).map((a2) => ({
+  const alternatives = [...d2.alternatives].sort((a2, b2) => compareValues$1(b2.value, a2.value)).map((a2) => ({
     label: a2.label,
     value: a2.value,
     downside: eastUiComponents.getSomeorUndefined(a2.downside),
@@ -63090,14 +63378,15 @@ function rankOptions(d2) {
     ...alternatives
   ].map((o2, i) => ({ ...o2, rank: i + 1 }));
 }
-function metaLine(o2) {
+function metaLine(o2, words) {
   const parts = [];
   if (o2.recommended) parts.push("recommended");
-  if (o2.confidence !== void 0) parts.push(`${Math.round(o2.confidence * 100)}% conf`);
+  if (o2.confidence !== void 0) parts.push(`${words.percent(o2.confidence)} conf`);
   if (!o2.recommended && o2.note !== void 0) parts.push(o2.note);
   return parts.join(" · ");
 }
 const OptionsFacet = React.memo(function OptionsFacet2({ decision, narrow }) {
+  const words = eastUiComponents.useFormatters();
   const options2 = rankOptions(decision);
   const maxUp = Math.max(...options2.map((o2) => Math.max(o2.value, 0)), 1e-9);
   const maxDown = Math.max(...options2.map((o2) => Math.abs(o2.downside ?? 0)), 1e-9);
@@ -63113,7 +63402,7 @@ const OptionsFacet = React.memo(function OptionsFacet2({ decision, narrow }) {
     return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "10px", children: [
       /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { ...caption, color: "fg", children: [
         "Options · ",
-        options2.length,
+        words.number(options2.length),
         " evaluated"
       ] }),
       options2.map((o2) => /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "4px", pl: "8px", ...o2.recommended ? { boxShadow: "inset 2px 0 0 var(--chakra-colors-accent-brand)" } : {}, children: [
@@ -63122,8 +63411,8 @@ const OptionsFacet = React.memo(function OptionsFacet2({ decision, narrow }) {
           " ",
           /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: o2.recommended ? "semibold" : "normal", children: o2.label })
         ] }),
-        meter(upLabel, o2.value / maxUp, fmt(decision, o2.value, signed2), signed2 ? "success" : "neutral"),
-        meter("If wrong", (o2.downside ?? 0) / maxDown, o2.downside !== void 0 ? fmt(decision, o2.downside, true) : "—", "danger")
+        meter(upLabel, o2.value / maxUp, fmt(words, decision, o2.value, signed2), signed2 ? "success" : "neutral"),
+        meter("If wrong", (o2.downside ?? 0) / maxDown, o2.downside !== void 0 ? fmt(words, decision, o2.downside, true) : "—", "danger")
       ] }, o2.rank))
     ] });
   }
@@ -63131,7 +63420,7 @@ const OptionsFacet = React.memo(function OptionsFacet2({ decision, narrow }) {
     /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "minmax(180px, 1.1fr) 1fr 1fr", alignItems: "baseline", gap: "8px", children: [
       /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { ...caption, color: "fg", children: [
         "Options · ",
-        options2.length,
+        words.number(options2.length),
         " evaluated"
       ] }),
       /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, textAlign: "center", children: "If wrong" }),
@@ -63153,15 +63442,15 @@ const OptionsFacet = React.memo(function OptionsFacet2({ decision, narrow }) {
             /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { minW: 0, pl: o2.recommended ? "6px" : "0", display: "flex", alignItems: "baseline", gap: "6px", children: [
               /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontSize: "11px", color: "fg.subtle", flexShrink: 0, children: o2.rank }),
               /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontSize: "12.5px", fontWeight: o2.recommended ? "semibold" : "normal", flexShrink: 0, children: o2.label }),
-              metaLine(o2) !== "" && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontSize: "10.5px", color: "fg.muted", minW: 0, truncate: true, children: metaLine(o2) })
+              metaLine(o2, words) !== "" && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontSize: "10.5px", color: "fg.muted", minW: 0, truncate: true, children: metaLine(o2, words) })
             ] }),
             /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", justifyContent: "flex-end", alignItems: "center", gap: "6px", height: "16px", children: o2.downside !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "10.5px", fontFamily: "mono", color: "fg.danger", flexShrink: 0, children: fmt(decision, o2.downside, true) }),
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "10.5px", fontFamily: "mono", color: "fg.danger", flexShrink: 0, children: fmt(words, decision, o2.downside, true) }),
               /* @__PURE__ */ jsxRuntime.jsx(react.Box, { height: "12px", width: `${Math.round(downFrac * 100)}%`, bg: "fg.danger", opacity: 0.55 })
             ] }) }),
             /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", alignItems: "center", gap: "6px", height: "16px", borderLeftWidth: "1px", borderColor: "border.strong", children: o2.value > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
               /* @__PURE__ */ jsxRuntime.jsx(react.Box, { height: "12px", width: `${Math.round(upFrac * 100)}%`, bg: signed2 ? "fg.success" : "fg.subtle", opacity: 0.6 }),
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "10.5px", fontFamily: "mono", color: signed2 ? "fg.success" : "fg.muted", flexShrink: 0, children: fmt(decision, o2.value, signed2) })
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "10.5px", fontFamily: "mono", color: signed2 ? "fg.success" : "fg.muted", flexShrink: 0, children: fmt(words, decision, o2.value, signed2) })
             ] }) })
           ]
         },
@@ -63175,8 +63464,9 @@ const ANSWERS = [
   { literal: "no", label: "No" },
   { literal: "unknown", label: "Don't know" }
 ];
-const JudgementFacet = React.memo(function JudgementFacet2({ decision, handle, leverPayloads }) {
+const JudgementFacet = React.memo(function JudgementFacet2({ decision, handle, contract }) {
   var _a2;
+  const words = eastUiComponents.useFormatters();
   const button = react.useRecipe({ key: "button" });
   const input = react.useRecipe({ key: "input" });
   const judgement = handle.judgementFor(decision.id);
@@ -63189,11 +63479,12 @@ const JudgementFacet = React.memo(function JudgementFacet2({ decision, handle, l
     if (knowledge !== stagedKnowledge) handle.addKnowledge(decision.id, knowledge);
   }, [knowledge, stagedKnowledge, handle, decision.id]);
   const levers = React.useMemo(
-    () => decision.levers.filter((l2) => leverPayloadEditable(leverPayloads[l2.case])),
-    [decision.levers, leverPayloads]
+    () => decision.levers.filter((l2) => leverPayloadEditable(contract == null ? void 0 : contract.payloads.get(l2.case))),
+    [decision.levers, contract]
   );
   const [leverCase, setLeverCase] = React.useState(((_a2 = levers[0]) == null ? void 0 : _a2.case) ?? "");
   const activeLever = levers.find((l2) => l2.case === leverCase) ?? levers[0];
+  const activePayload = activeLever === void 0 ? void 0 : contract == null ? void 0 : contract.payloads.get(activeLever.case);
   const gate = handle.commitStateFor(decision.id);
   const gateHint = (gate == null ? void 0 : gate.type) === "gated" ? gate.value === 1n ? "Answer the judgement question to enable apply" : `Answer the ${gate.value} judgement questions to enable apply` : (gate == null ? void 0 : gate.type) === "blocked" ? "Commit blocked — an answer contradicts the recommendation" : (gate == null ? void 0 : gate.type) === "handoff" ? "Awaiting handoff — an answer was don't know" : null;
   const onInject = React.useCallback((constraint) => {
@@ -63239,8 +63530,7 @@ const JudgementFacet = React.memo(function JudgementFacet2({ decision, handle, l
     (levers.length > 0 || judgement.constraints.length > 0) && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "6px", children: [
       /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, children: "Inject constraint · next run folds it in" }),
       judgement.constraints.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", gap: "12px", flexWrap: "wrap", children: judgement.constraints.map((c2, i) => {
-        const tag = c2.type;
-        const f2 = formatConstraint(c2, leverPayloads[tag], decision.levers);
+        const f2 = formatConstraint(c2, contract, decision.levers, words);
         return /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { as: "span", fontFamily: "mono", fontSize: "11px", children: [
           /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "accent.brand", fontWeight: "semibold", children: f2.lever }),
           " ",
@@ -63249,7 +63539,7 @@ const JudgementFacet = React.memo(function JudgementFacet2({ decision, handle, l
           /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "semibold", children: f2.value })
         ] }, i);
       }) }),
-      activeLever !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "8px", flexWrap: "wrap", children: [
+      activeLever !== void 0 && activePayload !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "8px", flexWrap: "wrap", children: [
         levers.length > 1 ? /* @__PURE__ */ jsxRuntime.jsx(react.Box, { flexShrink: 0, css: { "& [data-scope=select][data-part=root]": { width: "auto", minWidth: "160px" } }, children: /* @__PURE__ */ jsxRuntime.jsx(
           eastUiComponents.EastChakraSelect,
           {
@@ -63271,7 +63561,7 @@ const JudgementFacet = React.memo(function JudgementFacet2({ decision, handle, l
           LeverEditor,
           {
             leverCase: activeLever.case,
-            payload: leverPayloads[activeLever.case],
+            payload: activePayload,
             onInject
           },
           activeLever.case
@@ -63294,11 +63584,54 @@ const JudgementFacet = React.memo(function JudgementFacet2({ decision, handle, l
     ] })
   ] });
 });
+function body(type) {
+  return type.type === "Recursive" && type.value.type === "wrapper" ? type.value.value.inner : type;
+}
+function constraintContractOf(judgementsType) {
+  const dict = body(judgementsType);
+  if (dict.type !== "Dict") return void 0;
+  const record = body(dict.value.value);
+  if (record.type !== "Struct") return void 0;
+  const field = record.value.find((f2) => f2.name === "constraints");
+  if (field === void 0) return void 0;
+  const constraints = body(field.type);
+  if (constraints.type !== "Array") return void 0;
+  const contract = constraints.value;
+  const cases = body(contract);
+  if (cases.type !== "Variant") return void 0;
+  return {
+    type: contract,
+    payloads: new Map(cases.value.map((c2) => [c2.name, c2.type]))
+  };
+}
+function useConstraintContract(ref) {
+  const workspace = getReactiveDatasetCache().getConfig().workspace ?? "";
+  return React.useMemo(() => {
+    if (ref === null) return void 0;
+    const judgements = getBindingTypes(workspace, ref.judgements.source);
+    return judgements === void 0 ? void 0 : constraintContractOf(judgements.sourceType);
+  }, [ref, workspace]);
+}
 const URGENCY_RANK = {
   overdue: 0,
   due: 1,
   routine: 2
 };
+const compareInstants = east.compareFor(east.DateTimeType);
+const compareValues = east.compareFor(east.FloatType);
+function compareByUrgency(a2, b2) {
+  const rank = URGENCY_RANK[a2.urgency.type] - URGENCY_RANK[b2.urgency.type];
+  if (rank !== 0) return rank;
+  const da = a2.deadline.type === "some" ? a2.deadline.value : void 0;
+  const db = b2.deadline.type === "some" ? b2.deadline.value : void 0;
+  if (da !== void 0 && db !== void 0) {
+    const byDeadline = compareInstants(da, db);
+    if (byDeadline !== 0) return byDeadline;
+  } else if (da !== db) {
+    return da === void 0 ? 1 : -1;
+  }
+  return compareValues(b2.value, a2.value);
+}
 const URGENCY_GROUP_LABEL = {
   overdue: "Overdue",
   due: "Due today",
@@ -63345,10 +63678,10 @@ const URGENCY_TONE = {
 };
 const EXIT_MS = 560;
 const NARROW_PX = 560;
-function decisionValue(d2, n2, showSign = false) {
-  return eastUiComponents.formatTick(n2, eastUiComponents.getSomeorUndefined(d2.format), showSign);
+function decisionValue(words, d2, n2, showSign = false) {
+  return words.value(n2, eastUiComponents.getSomeorUndefined(d2.format), showSign);
 }
-function deadlineSuffix(d2) {
+function deadlineSuffix(d2, words) {
   const deadline = eastUiComponents.getSomeorUndefined(d2.deadline);
   if (deadline === void 0) return "";
   if (d2.urgency.type === "overdue") {
@@ -63357,34 +63690,16 @@ function deadlineSuffix(d2) {
     if (hours < 48) return ` ${hours}h`;
     return ` ${Math.round(hours / 24)}d`;
   }
-  if (d2.urgency.type === "due") {
-    const h2 = deadline.getHours();
-    const m2 = deadline.getMinutes();
-    const meridiem = h2 >= 12 ? "pm" : "am";
-    const clock2 = h2 % 12 === 0 ? 12 : h2 % 12;
-    return m2 === 0 ? ` ${clock2}${meridiem}` : ` ${clock2}:${String(m2).padStart(2, "0")}${meridiem}`;
-  }
+  if (d2.urgency.type === "due") return ` ${words.time(deadline)}`;
   return "";
 }
-function useLeverPayloads(ref) {
-  const cache3 = getReactiveDatasetCache();
-  const workspace = cache3.getConfig().workspace ?? "";
-  return React.useMemo(() => {
-    var _a2, _b2, _c2;
-    if (!ref) return {};
-    const judgements = getBindingTypes(workspace, ref.judgements.source);
-    if (!(judgements == null ? void 0 : judgements.sourceType)) return {};
-    const root2 = normalizeTypeValue(judgements.sourceType);
-    const constraint = (_c2 = (_b2 = (_a2 = root2.value) == null ? void 0 : _a2.fields) == null ? void 0 : _b2["constraints"]) == null ? void 0 : _c2.value;
-    return (constraint == null ? void 0 : constraint.type) === "Variant" ? constraint.cases ?? {} : {};
-  }, [ref, workspace]);
-}
-const Row = React.memo(function Row2({ decision, handle, selected: selected2, narrow, leverPayloads, modify, evidence, defaultFacet, facetInclude, apply: apply2, reject: reject2, leaving, storageKey }) {
+const Row = React.memo(function Row2({ decision, handle, selected: selected2, narrow, contract, modify, evidence, defaultFacet, facetInclude, apply: apply2, reject: reject2, leaving, storageKey }) {
   var _a2, _b2;
   const dq = react.useSlotRecipe({ key: "decisionQueue" });
   const status = react.useSlotRecipe({ key: "status" });
   const tabs = react.useSlotRecipe({ key: "facetTabs" });
   const button = react.useRecipe({ key: "button" });
+  const words = eastUiComponents.useFormatters();
   const rs = dq({});
   const ts = tabs({});
   const st = status({ status: URGENCY_TONE[decision.urgency.type], size: "md" });
@@ -63410,10 +63725,15 @@ const Row = React.memo(function Row2({ decision, handle, selected: selected2, na
   const handleReject = React.useCallback(() => {
     reject2(decision);
   }, [reject2, decision]);
+  const stageUpdate = handle.update;
+  const updateDecision = React.useCallback((next2) => {
+    stageUpdate(next2);
+    return null;
+  }, [stageUpdate]);
   const probe = React.useMemo(() => {
     if (!selected2 || facet !== "modify" || !modify) return null;
-    return modify(decision, handle.update);
-  }, [selected2, facet, modify, decision, handle.update]);
+    return modify(decision, updateDecision);
+  }, [selected2, facet, modify, decision, updateDecision]);
   const canvas = React.useMemo(() => {
     if (!selected2 || facet !== "evidence" || !evidence) return null;
     return evidence(decision);
@@ -63462,11 +63782,11 @@ const Row = React.memo(function Row2({ decision, handle, selected: selected2, na
     /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: st.indicator }),
     /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: st.label, children: [
       decision.urgency.type,
-      deadlineSuffix(decision)
+      deadlineSuffix(decision, words)
     ] })
   ] });
   const valueSigned = ((_b2 = eastUiComponents.getSomeorUndefined(decision.valueAxis)) == null ? void 0 : _b2.signed) ?? true;
-  const valueText = /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontFamily: "mono", fontWeight: "semibold", textAlign: "right", ...valueSigned && decision.value >= 0 && selected2 ? { color: "fg.success" } : {}, children: decisionValue(decision, decision.value, valueSigned && selected2) });
+  const valueText = /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontFamily: "mono", fontWeight: "semibold", textAlign: "right", ...valueSigned && decision.value >= 0 && selected2 ? { color: "fg.success" } : {}, children: decisionValue(words, decision, decision.value, valueSigned && selected2) });
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: rs.rowShell, ...leaving ? { "data-leaving": leaving } : {}, children: [
     narrow ? /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { px: "14px", py: "10px", children: [
       /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", justifyContent: "space-between", alignItems: "baseline", children: [
@@ -63490,7 +63810,7 @@ const Row = React.memo(function Row2({ decision, handle, selected: selected2, na
     selected2 && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { px: narrow ? "14px" : "18px", py: "12px", borderTopWidth: "1px", borderColor: "border.subtle", bg: "bg.canvas", children: [
       facet === "evidence" && /* @__PURE__ */ jsxRuntime.jsx(EvidenceFacet, { decision, children: canvas != null && /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraComponent, { value: canvas, storageKey: `${storageKey}-evidence-${decision.id}` }) }),
       facet === "options" && /* @__PURE__ */ jsxRuntime.jsx(OptionsFacet, { decision, narrow }),
-      facet === "judgement" && /* @__PURE__ */ jsxRuntime.jsx(JudgementFacet, { decision, handle, leverPayloads }),
+      facet === "judgement" && /* @__PURE__ */ jsxRuntime.jsx(JudgementFacet, { decision, handle, contract }),
       facet === "modify" && probe != null && /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraComponent, { value: probe, storageKey: `${storageKey}-modify-${decision.id}` })
     ] })
   ] });
@@ -63499,6 +63819,7 @@ const RoutineGroup = React.memo(function RoutineGroup2({ routine, acceptAll, lea
   const dq = react.useSlotRecipe({ key: "decisionQueue" });
   const status = react.useSlotRecipe({ key: "status" });
   const button = react.useRecipe({ key: "button" });
+  const words = eastUiComponents.useFormatters();
   const rs = dq({});
   const st = status({ status: "neutral", size: "md" });
   const total = React.useMemo(() => routine.reduce((acc, d2) => acc + d2.value, 0), [routine]);
@@ -63520,15 +63841,15 @@ const RoutineGroup = React.memo(function RoutineGroup2({ routine, acceptAll, lea
           d2.kind
         ] })
       ] }),
-      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: rs.routineValue, children: decisionValue(d2, d2.value) })
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: rs.routineValue, children: decisionValue(words, d2, d2.value) })
     ] }) }, d2.id)),
     /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: rs.summary, ...narrow ? { marginLeft: "0", flexWrap: "wrap" } : {}, children: [
       /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: rs.summaryCap, children: [
-        routine.length,
+        words.number(routine.length),
         " routine"
       ] }),
       /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.subtle", children: "·" }),
-      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontWeight: "semibold", children: eastUiComponents.formatTick(total, format2) }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontWeight: "semibold", children: words.value(total, format2) }),
       /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.muted", children: "total" }),
       acceptAll && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "button", css: button({ variant: "solid", size: "xs" }), ml: "auto", onClick: handleAcceptAll, children: "Accept all" })
     ] })
@@ -63537,6 +63858,7 @@ const RoutineGroup = React.memo(function RoutineGroup2({ routine, acceptAll, lea
 const GroupHead = React.memo(function GroupHead2({ group: group2, collapsible, collapsed, onToggle, acceptAll }) {
   const dq = react.useSlotRecipe({ key: "decisionQueue" });
   const button = react.useRecipe({ key: "button" });
+  const words = eastUiComponents.useFormatters();
   const rs = dq({});
   const format2 = group2.decisions[0] ? eastUiComponents.getSomeorUndefined(group2.decisions[0].format) : void 0;
   const handleToggle = React.useCallback(() => {
@@ -63551,11 +63873,11 @@ const GroupHead = React.memo(function GroupHead2({ group: group2, collapsible, c
     /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: rs.groupLabel, children: [
       group2.label,
       " · ",
-      group2.decisions.length
+      words.number(group2.decisions.length)
     ] }),
     /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: rs.groupSummary, children: [
-      eastUiComponents.formatTick(group2.total, format2),
-      group2.pastSla > 0 ? ` · ${group2.pastSla} past SLA` : ""
+      words.value(group2.total, format2),
+      group2.pastSla > 0 ? ` · ${words.number(group2.pastSla)} past SLA` : ""
     ] }),
     acceptAll && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "button", css: button({ variant: "solid", size: "xs" }), onClick: handleAcceptAll, children: "Accept all" })
   ] });
@@ -63567,10 +63889,11 @@ const EastChakraDecisionQueue = React.memo(function EastChakraDecisionQueue2({ v
   const dq = react.useSlotRecipe({ key: "decisionQueue" });
   const qs = dq({});
   const chip = react.useRecipe({ key: "chip" });
+  const words = eastUiComponents.useFormatters();
   const handleRef = value.handle;
   const handle = useDecisionHandle(handleRef);
   const decisions = handle.decisions;
-  const leverPayloads = useLeverPayloads(handleRef);
+  const contract = useConstraintContract(handleRef);
   const railAffordances = eastUiComponents.getSomeorUndefined(value.affordances);
   const sliceHandle = eastUiComponents.getSomeorUndefined(value.slice) ?? null;
   eastUiComponents.useSliceReactivity(sliceHandle == null ? void 0 : sliceHandle.key);
@@ -63610,14 +63933,8 @@ const EastChakraDecisionQueue = React.memo(function EastChakraDecisionQueue2({ v
   const heading = eastUiComponents.getSomeorUndefined(value.heading) ?? "Decisions waiting";
   const onApply = React.useMemo(() => eastUiComponents.getSomeorUndefined(value.onApply), [value.onApply]);
   const onReject = React.useMemo(() => eastUiComponents.getSomeorUndefined(value.onReject), [value.onReject]);
-  const modify = React.useMemo(
-    () => eastUiComponents.getSomeorUndefined(value.modify),
-    [value.modify]
-  );
-  const evidence = React.useMemo(
-    () => eastUiComponents.getSomeorUndefined(value.evidence),
-    [value.evidence]
-  );
+  const modify = React.useMemo(() => eastUiComponents.getSomeorUndefined(value.modify), [value.modify]);
+  const evidence = React.useMemo(() => eastUiComponents.getSomeorUndefined(value.evidence), [value.evidence]);
   const defaultFacet = ((_a2 = eastUiComponents.getSomeorUndefined(value.defaultFacet)) == null ? void 0 : _a2.type) ?? "evidence";
   const facetInclude = React.useMemo(() => {
     const facets = eastUiComponents.getSomeorUndefined(value.facets);
@@ -63666,15 +63983,7 @@ const EastChakraDecisionQueue = React.memo(function EastChakraDecisionQueue2({ v
     for (const { decision } of exiting.values()) {
       if (!merged2.some((d2) => d2.id === decision.id)) merged2.push(decision);
     }
-    merged2.sort((a2, b2) => {
-      var _a3, _b2;
-      const r2 = URGENCY_RANK[a2.urgency.type] - URGENCY_RANK[b2.urgency.type];
-      if (r2 !== 0) return r2;
-      const da = ((_a3 = eastUiComponents.getSomeorUndefined(a2.deadline)) == null ? void 0 : _a3.getTime()) ?? Infinity;
-      const db = ((_b2 = eastUiComponents.getSomeorUndefined(b2.deadline)) == null ? void 0 : _b2.getTime()) ?? Infinity;
-      if (da !== db) return da - db;
-      return b2.value - a2.value;
-    });
+    merged2.sort(compareByUrgency);
     return {
       merged: merged2,
       active: merged2.filter((d2) => d2.urgency.type !== "routine"),
@@ -63713,7 +64022,7 @@ const EastChakraDecisionQueue = React.memo(function EastChakraDecisionQueue2({ v
       handle,
       selected: selectedId === d2.id,
       narrow,
-      leverPayloads,
+      contract,
       modify,
       evidence,
       defaultFacet,
@@ -63740,13 +64049,13 @@ const EastChakraDecisionQueue = React.memo(function EastChakraDecisionQueue2({ v
       ) }),
       /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: es.meta, gap: "10px", children: [
         /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", children: [
-          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg", fontWeight: "semibold", children: visible }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg", fontWeight: "semibold", children: words.number(visible) }),
           narrow ? "" : " decisions"
         ] }),
         pastSla > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
           /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: es.sep, children: "·" }),
           /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", children: [
-            /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.danger", fontWeight: "semibold", children: pastSla }),
+            /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.danger", fontWeight: "semibold", children: words.number(pastSla) }),
             narrow ? " SLA" : " past SLA"
           ] })
         ] })
@@ -63808,34 +64117,24 @@ function verdictPresentation(verdict) {
       return { tone: "warning", verb: "handed off", detail: verdict.value !== "" ? verdict.value : null };
   }
 }
-function formatResolvedAt(j2) {
+function formatResolvedAt(j2, words) {
   if (j2.resolvedAt.type !== "some") return null;
   const d2 = j2.resolvedAt.value;
-  const month = d2.toLocaleString("en", { month: "short" });
-  const time2 = `${String(d2.getHours()).padStart(2, "0")}:${String(d2.getMinutes()).padStart(2, "0")}`;
-  return `${month} ${d2.getDate()} · ${time2}`;
+  return `${words.monthDay(d2)} · ${words.time(d2)}`;
 }
 const EastChakraDecisionJournal = React.memo(function EastChakraDecisionJournal2({ value }) {
   const eyebrow = react.useSlotRecipe({ key: "eyebrowRow" });
   const status = react.useSlotRecipe({ key: "status" });
   const es = eyebrow({});
+  const words = eastUiComponents.useFormatters();
   const handle = useDecisionHandle(value.handle);
   const heading = eastUiComponents.getSomeorUndefined(value.heading) ?? "Decision journal";
-  const cache3 = getReactiveDatasetCache();
-  const workspace = cache3.getConfig().workspace ?? "";
-  const leverPayloads = React.useMemo(() => {
-    var _a2, _b2, _c2;
-    const judgements = getBindingTypes(workspace, value.handle.judgements.source);
-    if (!(judgements == null ? void 0 : judgements.sourceType)) return {};
-    const root2 = normalizeTypeValue(judgements.sourceType);
-    const constraint = (_c2 = (_b2 = (_a2 = root2.value) == null ? void 0 : _a2.fields) == null ? void 0 : _b2["constraints"]) == null ? void 0 : _c2.value;
-    return (constraint == null ? void 0 : constraint.type) === "Variant" ? constraint.cases ?? {} : {};
-  }, [workspace, value.handle]);
+  const contract = useConstraintContract(value.handle);
   const entries = React.useMemo(() => handle.journal ?? [], [handle.journal]);
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { borderWidth: "1px", borderColor: "border.strong", borderRadius: "6px", background: "bg.canvas", overflow: "hidden", children: [
     /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: es.root, children: [
       /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: es.lbl, children: heading }),
-      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: es.meta, children: entries.length === 1 ? "1 entry" : `${entries.length} entries` })
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: es.meta, children: entries.length === 1 ? "1 entry" : `${words.number(entries.length)} entries` })
     ] }),
     /* @__PURE__ */ jsxRuntime.jsx(
       react.Box,
@@ -63847,7 +64146,7 @@ const EastChakraDecisionJournal = React.memo(function EastChakraDecisionJournal2
           if (!verdict) return null;
           const { tone, verb, detail } = verdictPresentation(verdict);
           const st = status({ status: tone, size: "md" });
-          const when = formatResolvedAt(j2);
+          const when = formatResolvedAt(j2, words);
           const knowledge = j2.knowledge.type === "some" && j2.knowledge.value !== "" ? j2.knowledge.value : null;
           return /* @__PURE__ */ jsxRuntime.jsxs(
             react.Box,
@@ -63886,8 +64185,7 @@ const EastChakraDecisionJournal = React.memo(function EastChakraDecisionJournal2
                   }
                 ),
                 j2.constraints.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", gap: "12px", flexWrap: "wrap", children: j2.constraints.map((c2, k2) => {
-                  const tag = c2.type;
-                  const f2 = formatConstraint(c2, leverPayloads[tag]);
+                  const f2 = formatConstraint(c2, contract, void 0, words);
                   return /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.ClauseChip, { field: f2.lever, op: f2.op, value: f2.value }, k2);
                 }) })
               ]
@@ -64206,6 +64504,7 @@ function useDatasetValue(apiUrl, repo, workspace, datasetPath, options2) {
   const { requestOptions, queryOverrides, enabled = true, hash: hash2, platforms, type } = options2;
   const platformImpls = platforms ?? defaultPlatformImplementations;
   const reqOpts = requestOptions ?? { token: null };
+  const queryClient = reactQuery.useQueryClient();
   const pathParts = React.useMemo(
     () => (datasetPath == null ? void 0 : datasetPath.split(".").filter(Boolean).map((v3) => east.variant("field", v3))) ?? [],
     [datasetPath]
@@ -64215,8 +64514,14 @@ function useDatasetValue(apiUrl, repo, workspace, datasetPath, options2) {
     queryFn: async () => {
       const result = await e3ApiClient.datasetGet(apiUrl, repo, workspace, pathParts, reqOpts);
       const decoded = east.decodeBeast2For(type, { platform: platformImpls })(result.data);
-      return { decoded, sizeBytes: result.data.length };
+      const value = { decoded, sizeBytes: result.data.length, hash: result.hash ?? hash2 ?? null };
+      if (value.hash !== hash2) {
+        queryClient.setQueryData(["datasetValue", apiUrl, repo, workspace, datasetPath, value.hash], value);
+        void queryClient.invalidateQueries({ queryKey: ["datasetStatus", apiUrl, repo, workspace, datasetPath] });
+      }
+      return value;
     },
+    select: (value) => value.hash === (hash2 ?? null) ? value : void 0,
     enabled: enabled && !!workspace && !!datasetPath && hash2 != null,
     ...queryOverrides
   });
@@ -64282,14 +64587,6 @@ function useTaskDetails(apiUrl, repo, workspace, taskName, options2) {
     ...options2 == null ? void 0 : options2.queryOverrides
   });
 }
-function getTaskKind(details) {
-  var _a2;
-  return ((_a2 = details.kind) == null ? void 0 : _a2.type) === "some" ? details.kind.value : null;
-}
-function getTaskMetadata(details) {
-  var _a2;
-  return ((_a2 = details.metadata) == null ? void 0 : _a2.type) === "some" ? details.metadata.value : null;
-}
 const variantStyles = {
   // Mode-aware semantic tokens (the raw `red.50` / `gray.50` washes rendered
   // as bright light boxes in dark mode — #362).
@@ -64427,6 +64724,10 @@ function pagingDebug(...args) {
   console.info("[e3-paging]", ...args);
 }
 const PAGE_SIZE = 500;
+function servedPageSize(requested, page) {
+  const trimmed = page.count < requested && page.offset + page.count < page.totalElements;
+  return trimmed ? Math.max(1, page.count) : requested;
+}
 const MAX_RETAINED_PAGES = 8;
 function pageRows(type, decoded, offset) {
   if (type.type === "Array") {
@@ -64466,6 +64767,7 @@ const PagedDatasetPreview = React.memo(function PagedDatasetPreview2({
   onDownload,
   onNotIndexed
 }) {
+  const words = eastUiComponents.useFormatters();
   const queryClient = reactQuery.useQueryClient();
   const [pages, setPages] = React.useState(/* @__PURE__ */ new Map());
   const [totals, setTotals] = React.useState(null);
@@ -64473,48 +64775,69 @@ const PagedDatasetPreview = React.memo(function PagedDatasetPreview2({
   const [error3, setError] = React.useState(null);
   const [jumpRow, setJumpRow] = React.useState(void 0);
   const inflightRef = React.useRef(/* @__PURE__ */ new Set());
+  const shownRef = React.useRef({ path: path2, hash: hash2 });
+  const [pageSize, setPageSize] = React.useState(PAGE_SIZE);
+  const pageSizeRef = React.useRef(PAGE_SIZE);
   React.useEffect(() => {
     pagingDebug(`reset (path=${path2}, hash=${hash2.slice(0, 8)})`);
+    shownRef.current = { path: path2, hash: hash2 };
     setPages(/* @__PURE__ */ new Map());
     setTotals(null);
     setError(null);
     setJumpRow(void 0);
-    inflightRef.current.clear();
+    inflightRef.current = /* @__PURE__ */ new Set();
+    pageSizeRef.current = PAGE_SIZE;
+    setPageSize(PAGE_SIZE);
   }, [path2, hash2]);
   const loadPage = React.useCallback((pageIdx) => {
-    if (inflightRef.current.has(pageIdx)) return;
-    inflightRef.current.add(pageIdx);
+    const inflight = inflightRef.current;
+    if (inflight.has(pageIdx)) return;
+    inflight.add(pageIdx);
+    const current = () => shownRef.current.path === path2 && shownRef.current.hash === hash2;
+    const size3 = pageSizeRef.current;
     setLoadingCount((n2) => n2 + 1);
-    pagingDebug(`fetch p${pageIdx} (offset=${pageIdx * PAGE_SIZE}, limit=${PAGE_SIZE}, hash=${hash2.slice(0, 8)})`);
+    pagingDebug(`fetch p${pageIdx} (offset=${pageIdx * size3}, limit=${size3}, hash=${hash2.slice(0, 8)})`);
     const pathParts2 = path2.split(".").filter(Boolean).map((v3) => east.variant("field", v3));
     const reqOpts = requestOptions ?? { token: null };
     queryClient.fetchQuery({
-      queryKey: ["datasetPage", apiUrl, repo, workspace, path2, hash2, `p${pageIdx}`],
+      queryKey: ["datasetPage", apiUrl, repo, workspace, path2, hash2, `p${pageIdx}@${size3}`],
       // Hash-pinned: the URL is a pure function of the bytes, so any
       // HTTP cache between here and the server can hold it immutably.
-      queryFn: () => e3ApiClient.datasetGetPage(apiUrl, repo, workspace, pathParts2, { offset: pageIdx * PAGE_SIZE, limit: PAGE_SIZE, hash: hash2 }, reqOpts),
+      queryFn: () => e3ApiClient.datasetGetPage(apiUrl, repo, workspace, pathParts2, { offset: pageIdx * size3, limit: size3, hash: hash2 }, reqOpts),
       staleTime: Infinity
       // pages of one content hash are immutable
     }).then((page) => {
+      if (!current()) return;
+      if (size3 !== pageSizeRef.current) return;
       const decoded = east.decodeBeast2For(type)(page.data);
       const rows = pageRows(type, decoded, page.offset);
       pagingDebug(
         `p${pageIdx} ok: count=${page.count} rows=${rows.length} offset=${page.offset} total=${page.totalElements} segs=${page.segmentCount}`,
         rows.length > 0 ? `first=${JSON.stringify(rows[0].label ?? "(derived)")}` : "(empty)"
       );
-      if (page.count < PAGE_SIZE && page.offset + page.count < page.totalElements) {
-        pagingDebug(`p${pageIdx} SHORT page: server clamped ${PAGE_SIZE} → ${page.count}`);
-      }
       setTotals({ elements: page.totalElements, bytes: page.totalBytes });
-      setPages((prev2) => new Map(prev2).set(pageIdx, rows));
+      const served = servedPageSize(size3, page);
+      if (served === size3) {
+        setPages((prev2) => new Map(prev2).set(pageIdx, rows));
+        return;
+      }
+      pagingDebug(`p${pageIdx} SHORT page: served ${page.count} of ${size3} — addressing pages by ${served}`);
+      pageSizeRef.current = served;
+      setPageSize(served);
+      setPages(pageIdx === 0 ? /* @__PURE__ */ new Map([[0, rows]]) : /* @__PURE__ */ new Map());
     }).catch((err) => {
       pagingDebug(`p${pageIdx} FAILED:`, err);
+      if (!current()) return;
+      if (err instanceof e3ApiClient.DatasetHashMismatchError) {
+        void queryClient.invalidateQueries({ queryKey: ["datasetStatus", apiUrl, repo, workspace, path2] });
+        return;
+      }
       if (err instanceof e3ApiClient.ApiError && err.code === "dataset_not_indexed") {
         onNotIndexed == null ? void 0 : onNotIndexed();
       }
       setError(err instanceof Error ? err : new Error(String(err)));
     }).finally(() => {
-      inflightRef.current.delete(pageIdx);
+      inflight.delete(pageIdx);
       setLoadingCount((n2) => n2 - 1);
     });
   }, [queryClient, apiUrl, repo, workspace, path2, hash2, requestOptions, type, onNotIndexed]);
@@ -64522,8 +64845,8 @@ const PagedDatasetPreview = React.memo(function PagedDatasetPreview2({
     if (totals === null && error3 === null) loadPage(0);
   }, [totals, error3, loadPage]);
   const onNeedRows = React.useCallback((startRow, endRow) => {
-    const first2 = Math.max(0, Math.floor(startRow / PAGE_SIZE));
-    const last2 = Math.max(first2, Math.ceil(endRow / PAGE_SIZE) - 1);
+    const first2 = Math.max(0, Math.floor(startRow / pageSize));
+    const last2 = Math.max(first2, Math.ceil(endRow / pageSize) - 1);
     const missing = [];
     for (let p2 = first2; p2 <= last2; p2++) {
       if (!pages.has(p2)) missing.push(p2);
@@ -64531,7 +64854,7 @@ const PagedDatasetPreview = React.memo(function PagedDatasetPreview2({
     pagingDebug(`need rows [${startRow}, ${endRow}) → pages ${first2}..${last2}, missing=[${missing.join(",")}], inflight=[${[...inflightRef.current].join(",")}]`);
     setPages((prev2) => internal$2.pruneRetainedPages(prev2, first2, last2, MAX_RETAINED_PAGES));
     for (const p2 of missing) loadPage(p2);
-  }, [pages, loadPage]);
+  }, [pages, loadPage, pageSize]);
   const keyType = React.useMemo(() => type.type === "Dict" ? type.value.key : type.type === "Set" ? type.value : null, [type]);
   const pathParts = React.useMemo(() => path2.split(".").filter(Boolean).map((v3) => east.variant("field", v3)), [path2]);
   const onFindKey = React.useCallback(async (query) => {
@@ -64568,11 +64891,11 @@ const PagedDatasetPreview = React.memo(function PagedDatasetPreview2({
   }), [type]);
   const paging = React.useMemo(() => totals === null ? null : {
     totalRows: totals.elements,
-    pageSize: PAGE_SIZE,
+    pageSize,
     pages,
     onNeedRows,
     scrollToRow: jumpRow
-  }, [totals, pages, onNeedRows, jumpRow]);
+  }, [totals, pageSize, pages, onNeedRows, jumpRow]);
   if (error3 !== null) {
     if (error3 instanceof e3ApiClient.ApiError && error3.code === "dataset_too_large") {
       return /* @__PURE__ */ jsxRuntime.jsxs(react.Flex, { height: "100%", direction: "column", align: "center", justify: "center", gap: 3, p: 6, children: [
@@ -64590,11 +64913,11 @@ const PagedDatasetPreview = React.memo(function PagedDatasetPreview2({
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Flex, { direction: "column", height: "100%", overflow: "hidden", children: [
     /* @__PURE__ */ jsxRuntime.jsxs(react.Flex, { px: 4, py: 2, gap: 2, align: "center", flexShrink: 0, borderBottom: "1px solid", borderColor: "border.subtle", children: [
       /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { fontSize: "xs", color: "fg.muted", whiteSpace: "nowrap", children: [
-        totals.elements.toLocaleString(),
+        words.number(totals.elements),
         " ",
         itemNoun,
         " · ",
-        formatSize(totals.bytes > 0 ? totals.bytes : sizeBytes)
+        formatSize(totals.bytes > 0 ? totals.bytes : sizeBytes, words)
       ] }),
       loadingCount > 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "xs", color: "fg.muted", children: "Loading…" }),
       keyType !== null && /* @__PURE__ */ jsxRuntime.jsx(
@@ -64611,12 +64934,17 @@ const PagedDatasetPreview = React.memo(function PagedDatasetPreview2({
     ] }),
     /* @__PURE__ */ jsxRuntime.jsx(react.Box, { flex: 1, minHeight: 0, overflow: "hidden", children: /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraValueTree, { value: treeValue, storageKey: `${path2}:page`, paging }) })
   ] });
-}, (prev2, next2) => prev2.path === next2.path && prev2.workspace === next2.workspace && prev2.hash === next2.hash && prev2.sizeBytes === next2.sizeBytes);
+}, (prev2, next2) => {
+  var _a2, _b2;
+  return prev2.apiUrl === next2.apiUrl && prev2.repo === next2.repo && prev2.workspace === next2.workspace && prev2.path === next2.path && prev2.hash === next2.hash && prev2.sizeBytes === next2.sizeBytes && ((_a2 = prev2.requestOptions) == null ? void 0 : _a2.token) === ((_b2 = next2.requestOptions) == null ? void 0 : _b2.token);
+});
 const DEFAULT_SIZE_LIMIT = 200 * 1024;
-function formatSize(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+const KB_FORMAT = east.variant("number", { minimumFractionDigits: east.some(1n), maximumFractionDigits: east.some(1n), signDisplay: east.none });
+const MB_FORMAT = east.variant("number", { minimumFractionDigits: east.some(2n), maximumFractionDigits: east.some(2n), signDisplay: east.none });
+function formatSize(bytes, words = eastUiComponents.formatters()) {
+  if (bytes < 1024) return `${words.number(bytes)} B`;
+  if (bytes < 1024 * 1024) return `${words.value(bytes / 1024, KB_FORMAT)} KB`;
+  return `${words.value(bytes / 1024 / 1024, MB_FORMAT)} MB`;
 }
 function DownloadButton({ onClick, label }) {
   const [downloading, setDownloading] = React.useState(false);
@@ -64644,6 +64972,7 @@ const DatasetPreview = React.memo(function DatasetPreview2({
   editable = false
 }) {
   var _a2;
+  const words = eastUiComponents.useFormatters();
   const statusQuery = useDatasetStatus(apiUrl, repo, workspace, path2, {
     ...requestOptions != null && { requestOptions },
     ...pollInterval !== void 0 && { pollInterval }
@@ -64671,12 +65000,29 @@ const DatasetPreview = React.memo(function DatasetPreview2({
   const setMutation = useDatasetSet(apiUrl, repo, workspace, requestOptions);
   const queryClient = reactQuery.useQueryClient();
   const decoded = (_a2 = valueQuery.data) == null ? void 0 : _a2.decoded;
-  const write = React.useCallback(async (next2) => {
-    if (workspace == null || path2 == null || type === void 0) return;
+  const edited = React.useRef(null);
+  const writing = React.useRef(0);
+  const writes = React.useRef(Promise.resolve());
+  React.useEffect(() => {
+    if (writing.current === 0) edited.current = null;
+  }, [decoded]);
+  const write = React.useCallback((next2) => {
+    if (workspace == null || path2 == null || type === void 0) return Promise.resolve();
     const treePath = path2.split(".").filter(Boolean).map((p2) => east.variant("field", p2));
     const data4 = east.encodeBeast2For(type)(next2);
-    await setMutation.mutateAsync({ path: treePath, data: data4 });
-    await queryClient.invalidateQueries({ queryKey: ["datasetStatus", apiUrl, repo, workspace, path2] });
+    edited.current = { value: next2 };
+    writing.current++;
+    const run = writes.current.then(async () => {
+      await setMutation.mutateAsync({ path: treePath, data: data4 });
+      await queryClient.invalidateQueries({ queryKey: ["datasetStatus", apiUrl, repo, workspace, path2] });
+    });
+    writes.current = run.catch(() => void 0);
+    return run.catch((err) => {
+      edited.current = null;
+      throw err;
+    }).finally(() => {
+      writing.current--;
+    });
   }, [apiUrl, repo, workspace, path2, type, setMutation, queryClient]);
   const keyType = React.useMemo(() => type === void 0 ? null : type.type === "Dict" ? type.value.key : type.type === "Set" ? type.value : null, [type]);
   const inlineKeys = React.useMemo(() => decoded === void 0 || type === void 0 ? null : type.type === "Dict" ? [...decoded.keys()] : type.type === "Set" ? [...decoded.values()] : null, [type, decoded]);
@@ -64712,11 +65058,12 @@ const DatasetPreview = React.memo(function DatasetPreview2({
   const treeValue = React.useMemo(() => {
     if (type === void 0 || decoded === void 0) return null;
     const root2 = eastUi.ValueTree.materialize(type, decoded);
+    const base = () => edited.current !== null ? edited.current.value : decoded;
     const wire = editable ? {
-      onEdit: east.some((p2, leaf) => write(eastUi.ValueTree.applyEdit(type, decoded, p2, { kind: "edit", leaf }))),
-      onInsert: east.some((p2) => write(eastUi.ValueTree.applyEdit(type, decoded, p2, { kind: "insert" }))),
-      onRemove: east.some((p2) => write(eastUi.ValueTree.applyEdit(type, decoded, p2, { kind: "remove" }))),
-      onTag: east.some((p2, tag) => write(eastUi.ValueTree.applyEdit(type, decoded, p2, { kind: "tag", tag })))
+      onEdit: east.some((p2, leaf) => write(eastUi.ValueTree.applyEdit(type, base(), p2, { kind: "edit", leaf }))),
+      onInsert: east.some((p2) => write(eastUi.ValueTree.applyEdit(type, base(), p2, { kind: "insert" }))),
+      onRemove: east.some((p2) => write(eastUi.ValueTree.applyEdit(type, base(), p2, { kind: "remove" }))),
+      onTag: east.some((p2, tag) => write(eastUi.ValueTree.applyEdit(type, base(), p2, { kind: "tag", tag })))
     } : { onEdit: east.none, onInsert: east.none, onRemove: east.none, onTag: east.none };
     return { root: root2, ...wire, style: east.some({ height: east.some("100%"), maxHeight: east.none, openDepth: east.none, toolbar: east.some(true) }) };
   }, [type, decoded, editable, write]);
@@ -64750,18 +65097,21 @@ const DatasetPreview = React.memo(function DatasetPreview2({
       /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "lg", color: "fg.warning", fontWeight: "bold", children: "Value too large to display" }),
       /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { color: "fg.muted", fontSize: "sm", children: [
         "The data is ",
-        formatSize(sizeBytes),
+        formatSize(sizeBytes, words),
         ", which exceeds the ",
-        formatSize(sizeLimit),
+        formatSize(sizeLimit, words),
         " display limit."
       ] }),
       /* @__PURE__ */ jsxRuntime.jsx(DownloadButton, { onClick: download, label: "Download value" })
     ] });
   }
+  if (valueQuery.error) {
+    const { message, details } = formatApiError(valueQuery.error);
+    return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Load failed", message, details: details ?? formatError(valueQuery.error) });
+  }
   if (valueQuery.isLoading || !valueQuery.data) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "loading", title: "Loading..." });
-  if (valueQuery.error) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Decode failed", message: valueQuery.error.message });
   const count = type === void 0 || decoded === void 0 ? null : type.type === "Array" ? decoded.length : type.type === "Set" || type.type === "Dict" ? decoded.size : null;
-  const countText = count === null ? "" : `${count.toLocaleString()} ${(type == null ? void 0 : type.type) === "Dict" ? "entries" : "items"} · `;
+  const countText = count === null ? "" : `${words.number(count)} ${(type == null ? void 0 : type.type) === "Dict" ? "entries" : "items"} · `;
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Flex, { direction: "column", height: "100%", overflow: "hidden", children: [
     /* @__PURE__ */ jsxRuntime.jsxs(react.Flex, { px: 4, py: 2, gap: 2, align: "center", flexShrink: 0, borderBottom: "1px solid", borderColor: "border.subtle", children: [
       keyType !== null && inlineKeys !== null && /* @__PURE__ */ jsxRuntime.jsx(
@@ -64777,7 +65127,7 @@ const DatasetPreview = React.memo(function DatasetPreview2({
       /* @__PURE__ */ jsxRuntime.jsxs(react.Flex, { flex: 1, justify: "flex-end", align: "center", gap: 2, children: [
         /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { fontSize: "xs", color: "fg.muted", children: [
           countText,
-          formatSize(sizeBytes)
+          formatSize(sizeBytes, words)
         ] }),
         /* @__PURE__ */ jsxRuntime.jsx(DownloadButton, { onClick: download })
       ] })
@@ -64830,19 +65180,15 @@ const UITaskPreview = React.memo(function UITaskPreview2({
   const workspace = (config2 == null ? void 0 : config2.workspace) ?? (e3 == null ? void 0 : e3.workspace) ?? null;
   const token2 = (config2 == null ? void 0 : config2.token) ?? (e3 == null ? void 0 : e3.token) ?? null;
   const requestOptions = { token: token2 };
+  const bound3 = cache3 == null ? void 0 : cache3.getConfig().workspace;
+  const foreign = (config2 == null ? void 0 : config2.workspace) !== void 0 && bound3 !== void 0 && config2.workspace !== bound3;
   const detailsQuery = useTaskDetails(apiUrl ?? "", repo, workspace, task, { requestOptions });
   const details = detailsQuery.data;
-  const kind = details ? getTaskKind(details) : null;
-  const isUI = kind === "ui";
-  const manifest = React.useMemo(() => {
-    if (!details || !isUI) return null;
-    const meta3 = getTaskMetadata(details);
-    return meta3 ? internal$1.decodeManifest(meta3) : { paths: [], functions: [], records: [], pages: [] };
-  }, [details, isUI]);
-  const outputPath = details ? treePathToString$1(details.output) : null;
+  const manifest = React.useMemo(() => (details == null ? void 0 : details.role.type) === "ui" ? details.role.value : null, [details]);
+  const outputPath = details ? treePathToString$1(details.output.path) : null;
   const preloads = React.useMemo(
-    () => manifest && workspace ? manifest.paths.map((path2) => ({ workspace, path: path2 })) : [],
-    [manifest, workspace]
+    () => manifest && workspace && !foreign ? manifest.paths.map((path2) => ({ workspace, path: path2 })) : [],
+    [manifest, workspace, foreign]
   );
   const { loading: preloading, error: preloadError } = usePreloadReactiveDatasets(preloads);
   const scopedPlatforms = React.useMemo(
@@ -64868,7 +65214,7 @@ const UITaskPreview = React.memo(function UITaskPreview2({
     [manifest]
   );
   React.useEffect(() => {
-    if (!cache3 || !manifest || !workspace) return;
+    if (!cache3 || !manifest || !workspace || foreign) return;
     for (const path2 of manifest.paths) {
       cache3.setRefetchInterval(workspace, path2, pollInterval);
     }
@@ -64877,7 +65223,7 @@ const UITaskPreview = React.memo(function UITaskPreview2({
         cache3.clearRefetchInterval(workspace, path2);
       }
     };
-  }, [cache3, manifest, workspace, pollInterval]);
+  }, [cache3, manifest, workspace, pollInterval, foreign]);
   const statusQuery = useDatasetStatus(apiUrl ?? "", repo, workspace, outputPath, { requestOptions });
   const valueQuery = useDatasetValue(apiUrl ?? "", repo, workspace, outputPath, {
     requestOptions,
@@ -64887,16 +65233,20 @@ const UITaskPreview = React.memo(function UITaskPreview2({
   });
   const store = React.useMemo(() => eastUiComponents.createUIStore(), [task]);
   if (!apiUrl) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Configuration error", message: "No apiUrl available — render UITaskPreview inside an <E3Provider> or pass a config prop." });
+  if (foreign) {
+    return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Workspace mismatch", message: `config names workspace "${config2 == null ? void 0 : config2.workspace}", and the data bindings read workspace "${bound3}", the one the surrounding <ReactiveDatasetProvider> serves: a page previews one workspace.` });
+  }
   if (detailsQuery.isLoading) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "loading", title: "Loading task..." });
   if (detailsQuery.error) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Error", message: detailsQuery.error.message });
   if (!details) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "info", title: "No task", message: `Task "${task}" not found` });
-  if (!isUI) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Not a UI task", message: `Task "${task}" has kind "${kind ?? "(none)"}"` });
+  if (!manifest) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Not a UI task", message: `Task "${task}" is a ${details.role.type} task` });
   if (preloadError) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Preload failed", message: preloadError.message });
   if (preloading) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "loading", title: "Loading datasets..." });
+  if (statusQuery.error) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Error", message: statusQuery.error.message });
   if (statusQuery.isLoading || !statusQuery.data) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "loading", title: "Loading..." });
   if (statusQuery.data.refType !== "value") return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "info", title: "No output yet", message: "Task has not produced a value" });
+  if (valueQuery.error) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Load failed", message: valueQuery.error.message });
   if (valueQuery.isLoading || !valueQuery.data) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "loading", title: "Loading..." });
-  if (valueQuery.error) return /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Decode failed", message: valueQuery.error.message });
   return /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.UIStoreProvider, { store, children: /* @__PURE__ */ jsxRuntime.jsx(ErrorBoundary, { children: /* @__PURE__ */ jsxRuntime.jsx(react.Box, { height: "100%", overflow: bare ? void 0 : "auto", p: bare ? void 0 : "4", minH: bare ? 0 : void 0, children: /* @__PURE__ */ jsxRuntime.jsx(
     eastUiComponents.EastChakraComponent,
     {
@@ -65353,7 +65703,7 @@ const DataTaskPreview = React.memo(function DataTaskPreview2({
   const detailsQuery = useTaskDetails(apiUrl, repo, workspace, task, {
     ...requestOptions != null && { requestOptions }
   });
-  const outputPath = detailsQuery.data ? treePathToString(detailsQuery.data.output) : null;
+  const outputPath = detailsQuery.data ? treePathToString(detailsQuery.data.output.path) : null;
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { height: "100%", display: "flex", flexDirection: "column", overflow: "hidden", children: [
     /* @__PURE__ */ jsxRuntime.jsx(
       react.Flex,
@@ -65417,13 +65767,14 @@ const TaskPreview = React.memo(function TaskPreview2({
   requestOptions,
   bare = false
 }) {
+  var _a2;
   const detailsQuery = useTaskDetails(apiUrl, repo, workspace, task, {
     ...requestOptions != null && { requestOptions }
   });
-  const kind = detailsQuery.data ? getTaskKind(detailsQuery.data) : null;
+  const isUI = ((_a2 = detailsQuery.data) == null ? void 0 : _a2.role.type) === "ui";
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { height: "100%", display: "flex", flexDirection: "column", overflow: "hidden", children: [
     !bare && /* @__PURE__ */ jsxRuntime.jsx(react.Flex, { px: 4, py: 2, borderBottom: "1px solid", borderColor: "border.subtle", bg: "bg.surface", align: "center", flexShrink: 0, children: /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "sm", fontWeight: "medium", color: "fg", children: task }) }),
-    /* @__PURE__ */ jsxRuntime.jsx(react.Box, { flex: 1, overflow: "hidden", minHeight: 0, children: detailsQuery.isLoading ? /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "loading", title: "Loading task..." }) : detailsQuery.error ? /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Error", message: detailsQuery.error.message }) : kind === "ui" ? /* @__PURE__ */ jsxRuntime.jsx(
+    /* @__PURE__ */ jsxRuntime.jsx(react.Box, { flex: 1, overflow: "hidden", minHeight: 0, children: detailsQuery.isLoading ? /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "loading", title: "Loading task..." }) : detailsQuery.error ? /* @__PURE__ */ jsxRuntime.jsx(StatusDisplay, { variant: "error", title: "Error", message: detailsQuery.error.message }) : isUI ? /* @__PURE__ */ jsxRuntime.jsx(
       UITaskPreview,
       {
         task,
@@ -65441,33 +65792,16 @@ const TaskPreview = React.memo(function TaskPreview2({
       }
     ) })
   ] });
-}, (prev2, next2) => prev2.task === next2.task && prev2.repo === next2.repo && prev2.workspace === next2.workspace && prev2.bare === next2.bare);
+}, (prev2, next2) => {
+  var _a2, _b2;
+  return prev2.task === next2.task && prev2.apiUrl === next2.apiUrl && prev2.repo === next2.repo && prev2.workspace === next2.workspace && prev2.bare === next2.bare && ((_a2 = prev2.requestOptions) == null ? void 0 : _a2.token) === ((_b2 = next2.requestOptions) == null ? void 0 : _b2.token);
+});
 function formatPrimitive(type, value) {
-  switch (type.type) {
-    case "Null":
-      return "null";
-    case "Boolean":
-      return value ? "true" : "false";
-    case "Integer":
-      return String(value);
-    case "Float": {
-      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}"`;
-    case "DateTime":
-      return value.toISOString();
-    case "Blob":
-      return `Blob[${value.length} bytes]`;
-    default:
-      return String(value);
-  }
+  if (type.type === "Blob") return `Blob[${value.length} bytes]`;
+  return east.printFor(type)(value);
 }
 function isPrimitive(type) {
-  return ["Null", "Boolean", "Integer", "Float", "String", "DateTime", "Blob", "Never"].includes(type.type);
+  return ["Null", "Boolean", "Integer", "Float", "String", "DateTime", "Blob"].includes(type.type);
 }
 function getTypeLabel(type, value) {
   switch (type.type) {
@@ -65589,8 +65923,8 @@ function ValueNode({
   }
   if (type.type === "Variant") {
     const cases = type.value;
-    const variant = value;
-    const activeCase = cases.find((c2) => c2.name === variant.type);
+    const chosen = value;
+    const activeCase = cases.find((c2) => c2.name === chosen.type);
     if (!activeCase) {
       return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { py: 0.5, display: "flex", alignItems: "center", gap: 2, children: [
         label && /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { as: "span", color: "accent.purple", fontWeight: "medium", children: [
@@ -65599,7 +65933,7 @@ function ValueNode({
         ] }),
         /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { as: "span", color: "fg.danger", children: [
           "Unknown variant: ",
-          variant.type
+          chosen.type
         ] })
       ] });
     }
@@ -65611,7 +65945,7 @@ function ValueNode({
         ] }),
         /* @__PURE__ */ jsxRuntime.jsxs(react.Badge, { size: "xs", colorPalette: "brand", variant: "subtle", children: [
           ".",
-          variant.type
+          chosen.type
         ] })
       ] });
     }
@@ -65623,14 +65957,14 @@ function ValueNode({
         ] }),
         /* @__PURE__ */ jsxRuntime.jsxs(react.Badge, { size: "xs", colorPalette: "brand", variant: "subtle", children: [
           ".",
-          variant.type
+          chosen.type
         ] })
       ] }),
       /* @__PURE__ */ jsxRuntime.jsx(react.Box, { pl: 4, children: /* @__PURE__ */ jsxRuntime.jsx(
         ValueNode,
         {
           type: activeCase.type,
-          value: variant.value,
+          value: chosen.value,
           depth: depth + 1
         }
       ) })
@@ -65838,8 +66172,6 @@ exports.funcChannelKey = funcChannelKey;
 exports.getBindingTypes = getBindingTypes;
 exports.getReactiveDatasetCache = getReactiveDatasetCache;
 exports.getStagedStore = getStagedStore;
-exports.getTaskKind = getTaskKind;
-exports.getTaskMetadata = getTaskMetadata;
 exports.initializeFunctionApi = initializeFunctionApi;
 exports.initializePagedApi = initializePagedApi;
 exports.initializeReactiveDatasetCache = initializeReactiveDatasetCache;
@@ -65847,6 +66179,7 @@ exports.initializeRecordApi = initializeRecordApi;
 exports.initializeStagedStore = initializeStagedStore;
 exports.isBindingTracking = isBindingTracking;
 exports.onWriteError = onWriteError;
+exports.pagedRevisionKey = pagedRevisionKey;
 exports.pagedTotalKey = pagedTotalKey;
 exports.pagedWindowKey = pagedWindowKey;
 exports.preloadReactiveDatasetList = preloadReactiveDatasetList;