@elaraai/e3-ui-components 1.0.79 → 1.0.80

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));
     }
   }
 }
@@ -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();
@@ -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 pagedTotalKey(workspace, path2) {
-  return `paged:${workspace}:${datasetPathToString(path2)}#total`;
+function pagedWindowKey(workspace, path2, revision, offset, limit2, selector2 = NO_INDEX) {
+  return `paged:${workspace}:${datasetPathToString(path2)}${selectorKey(selector2)}@${revision}#${offset}+${limit2}`;
 }
-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 pagedTotalKey(workspace, path2, revision, selector2 = NO_INDEX) {
+  return `paged:${workspace}:${datasetPathToString(path2)}${selectorKey(selector2)}@${revision}#total`;
 }
-function toFindQuery(query) {
+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, 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()
   ];
 }
@@ -4203,8 +4597,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();
@@ -4437,8 +4838,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 +8612,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 +8671,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 +8987,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 +9014,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 +9047,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 +9097,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() {
@@ -64206,6 +64591,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 +64601,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 +64674,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).
@@ -64473,17 +64857,21 @@ 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 });
   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();
   }, [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;
     setLoadingCount((n2) => n2 + 1);
     pagingDebug(`fetch p${pageIdx} (offset=${pageIdx * PAGE_SIZE}, limit=${PAGE_SIZE}, hash=${hash2.slice(0, 8)})`);
     const pathParts2 = path2.split(".").filter(Boolean).map((v3) => east.variant("field", v3));
@@ -64496,6 +64884,7 @@ const PagedDatasetPreview = React.memo(function PagedDatasetPreview2({
       staleTime: Infinity
       // pages of one content hash are immutable
     }).then((page) => {
+      if (!current()) return;
       const decoded = east.decodeBeast2For(type)(page.data);
       const rows = pageRows(type, decoded, page.offset);
       pagingDebug(
@@ -64509,12 +64898,17 @@ const PagedDatasetPreview = React.memo(function PagedDatasetPreview2({
       setPages((prev2) => new Map(prev2).set(pageIdx, rows));
     }).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]);
@@ -64611,7 +65005,10 @@ 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`;
@@ -64671,12 +65068,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 +65126,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]);
@@ -64758,8 +65173,11 @@ const DatasetPreview = React.memo(function DatasetPreview2({
       /* @__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"} · `;
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Flex, { direction: "column", height: "100%", overflow: "hidden", children: [
@@ -64830,19 +65248,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 +65282,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 +65291,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 +65301,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 +65771,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 +65835,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,7 +65860,10 @@ 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":
@@ -65838,8 +66260,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 +66267,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;