@elaraai/e3-ui-components 1.0.68 → 1.0.69

package/dist/index.js

@@ -18,21 +18,22 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   }
 });
 var _focused, _cleanup, _setup, _a, _provider, _providerCalled, _b, _online, _cleanup2, _setup2, _c, _gcTimeout, _d, _initialState, _revertState, _cache, _client, _retryer, _defaultOptions, _abortSignalConsumed, _Query_instances, isInitialPausedFetch_fn, dispatch_fn, _e, _client2, _observers, _mutationCache, _retryer2, _Mutation_instances, dispatch_fn2, _f, _mutations, _scopes, _mutationId, _g, _queries, _h, _queryCache, _mutationCache2, _defaultOptions2, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline, _i, _j;
-import { variant, SortedMap, compareFor, EastError, fromEastTypeValue, East, none as none$1, some, OptionType, BooleanType, NullType, ConflictError, equalFor, toEastTypeValue, PatchType, diffFor, applyFor, encodeBeast2For, decodeBeast2For, BlobType, StructType, StringType, walkPatch, pathToString, pathDisplay, printFor, isVariant, prunePatchFor, detectConflictsFor, mergeWithResolutionsFor, validatePatchFor, isEastSet, isEastDict, ArrayType, parseFor } from "@elaraai/east";
+import { variant, SortedMap, compareFor, EastError, fromEastTypeValue, East, none as none$1, some, OptionType, BooleanType, NullType, ConflictError, equalFor, toEastTypeValue, PatchType, diffFor, applyFor, encodeBeast2For, decodeBeast2For, BlobType, IntegerType, StructType, StringType, walkPatch, pathToString, pathDisplay, printFor, isVariant, prunePatchFor, detectConflictsFor, mergeWithResolutionsFor, validatePatchFor, isEastSet, isEastDict, ArrayType, parseFor } from "@elaraai/east";
 import { EastTypeType } from "@elaraai/east/internal";
-import { DataBindModeType, DataBindPrimitives, bindPlatformFn, FuncBindPrimitives, FuncErrorType, FuncStatusType, funcBindPlatformFn, RecordBindPrimitives, recordBindPlatformFn, Diff, Ontology, FuncBindHandleType, Experiment, decisionBindPlatformFn, DecisionBindPrimitives, DecisionConstraintType, DiffBindingType, CommitStateType, VerdictType, AnswerType, judgementInputType, DecisionType, DecisionQueue, DecisionJournal, decodeManifest } from "@elaraai/e3-ui/internal";
+import { DataBindModeType, DataBindPrimitives, bindPlatformFn, DataPagedPrimitives, bindPagedPlatformFn, FuncBindPrimitives, FuncErrorType, FuncStatusType, funcBindPlatformFn, RecordBindPrimitives, recordBindPlatformFn, Diff, Ontology, FuncBindHandleType, Experiment, decisionBindPlatformFn, DecisionBindPrimitives, DecisionConstraintType, DiffBindingType, CommitStateType, VerdictType, AnswerType, judgementInputType, DecisionType, DecisionQueue, DecisionJournal, decodeManifest } from "@elaraai/e3-ui/internal";
 import { registerReactiveTracker, registerPlatformImplementation, StateRuntime, getRegisteredPlatformImplementations, boundSliceConfig } from "@elaraai/east-ui-components/platform";
 import { TreePathType, DatasetStatusType } from "@elaraai/e3-types";
-import { workspaceStatus, datasetListAt, datasetList, dataflowExecuteLaunch, datasetSet, datasetGet, ApiError, workspaceFunctionCall, workspaceFunctionList, workspaceRecordHistory, workspaceRecordMutate, workspaceRecordDescribe, repoCreate, repoGc, repoGcStart, repoGcStatus, repoList, repoRemove, repoStatus, packageExport, packageGet, packageImport, packageList, packageRemove, workspaceCreate, workspaceDeploy, workspaceExport, workspaceGet, workspaceList, workspaceRemove, datasetGetStatus, datasetListRecursive, datasetListRecursivePaths, datasetListWithStatus, taskExecutionList, taskGet, taskList, dataflowCancel, dataflowExecute, dataflowExecutePoll, dataflowGraph, taskLogs, datasetGetPage, datasetFindKey } from "@elaraai/e3-api-client";
+import { workspaceStatus, datasetListAt, datasetList, dataflowExecuteLaunch, datasetSet, datasetGet, ApiError, datasetFindKey, datasetGetPage, workspaceFunctionCall, workspaceFunctionList, workspaceRecordHistory, workspaceRecordMutate, workspaceRecordDescribe, repoCreate, repoGc, repoGcStart, repoGcStatus, repoList, repoRemove, repoStatus, packageExport, packageGet, packageImport, packageList, packageRemove, workspaceCreate, workspaceDeploy, workspaceExport, workspaceGet, workspaceList, workspaceRemove, datasetGetStatus, datasetListRecursive, datasetListRecursivePaths, datasetListWithStatus, taskExecutionList, taskGet, taskList, dataflowCancel, dataflowExecute, dataflowExecutePoll, dataflowGraph, taskLogs } from "@elaraai/e3-api-client";
+import { SeekQueryType, SeekRangeType, ValueTree } from "@elaraai/east-ui";
 import { jsx as jsx$1, Fragment, jsxs } from "react/jsx-runtime";
 import * as React from "react";
 import React__default, { useId, useMemo, useContext, createContext, useRef, useEffect, useState, useCallback, useSyncExternalStore, memo, forwardRef, useLayoutEffect, Fragment as Fragment$1, Component } from "react";
 import { Box, Flex, Text, HStack, Input, useSlotRecipe, useRecipe, VStack, useToken, Drawer, Portal, Field, NativeSelect, Textarea, chakra, Tooltip, SegmentGroup, Menu, HoverCard, useChakraContext, Spinner, Code, Clipboard, IconButton, Button, Tabs, Badge, useTabs } from "@chakra-ui/react";
-import { implementUIComponent, getSomeorUndefined, formatPredicate, SliceEditPopover, SlicePredicateBuilder, EastChakraSelect, EastChakraStringInput, EastChakraDateTimeInput, EastChakraFloatInput, EastChakraIntegerInput, formatTick, useSliceReactivity, useContainerBelow, usePersistedState, SliceRailCluster, EastChakraComponent, ClauseChip, StateImpl, NavImpl, SliceImpl, SliceApplyImpl, OverlayImpl, ClipboardImpl, DownloadImpl, ShareImpl, LoadingIcon, EastChakraCombobox, EastChakraValueTree, createUIStore, UIStoreProvider } from "@elaraai/east-ui-components";
+import { implementUIComponent, getSomeorUndefined, formatPredicate, SliceEditPopover, SlicePredicateBuilder, EastChakraSelect, EastChakraStringInput, EastChakraDateTimeInput, EastChakraFloatInput, EastChakraIntegerInput, formatTick, useSliceReactivity, useContainerBelow, usePersistedState, SliceRailCluster, EastChakraComponent, ClauseChip, StateImpl, NavImpl, SliceImpl, SliceApplyImpl, OverlayImpl, ClipboardImpl, DownloadImpl, ShareImpl, LoadingIcon, DatasetKeySearch, EastChakraValueTree, keyRangePredicates, createUIStore, UIStoreProvider } from "@elaraai/east-ui-components";
+import { DatasetKeySearch as DatasetKeySearch2 } from "@elaraai/east-ui-components";
 import { createPortal } from "react-dom";
 import { sliceMatches } from "@elaraai/east-ui/internal";
 import { QueryClient as QueryClient$1, QueryClientProvider, useMutation, useQuery, keepPreviousData, useQueryClient } from "@tanstack/react-query";
-import { ValueTree } from "@elaraai/east-ui";
 import { useVirtualizer } from "@tanstack/react-virtual";
 var Subscribable = class {
   constructor() {
@@ -3593,6 +3594,14 @@ class TrackedChannelStore {
   isTracking() {
     return this.trackingContext !== null;
   }
+  /** Whether the CURRENT evaluation has already read this channel. A cache
+   *  that evicts by least-recently-read must never drop one of these: a read
+   *  pass longer than the cache would otherwise evict its own head, and the
+   *  next pass would find it gone (#581). */
+  isTracked(key) {
+    var _a2;
+    return ((_a2 = this.trackingContext) == null ? void 0 : _a2.has(key)) ?? false;
+  }
   /** Record a channel-key dependency for the current render (no-op when not
    *  tracking). */
   track(key) {
@@ -3674,6 +3683,397 @@ class TrackedChannelStore {
     this.keyVersions.clear();
   }
 }
+function createDefaultPagedApi(apiUrl, repo, getToken) {
+  const opts = () => ({ token: getToken() });
+  return {
+    async getPage(workspace, path2, window3) {
+      return datasetGetPage(apiUrl, repo, workspace, path2, window3, opts());
+    },
+    async findKey(workspace, path2, query) {
+      return datasetFindKey(apiUrl, repo, workspace, path2, query, opts());
+    }
+  };
+}
+const RETRY_AFTER_MS = 2e3;
+const MAX_RETAINED_WINDOWS = 24;
+const PERMANENT_PAGE_ERRORS = /* @__PURE__ */ new Set(["dataset_not_pageable"]);
+function isPermanentPageError(err) {
+  const code = err == null ? void 0 : err.code;
+  return typeof code === "string" && PERMANENT_PAGE_ERRORS.has(code);
+}
+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, platform) {
+  if (keyTypeOf(sourceType) === null) return none$1;
+  const { seek } = DataPagedPrimitives;
+  return some(East.compile(
+    East.function([SeekQueryType], OptionType(SeekRangeType), ($3, query) => {
+      $3.return(seek([T2], pathExpr, query));
+    }),
+    platform
+  ));
+}
+function pagedWindowKey(workspace, path2, offset, limit2) {
+  return `paged:${workspace}:${datasetPathToString(path2)}#${offset}+${limit2}`;
+}
+function pagedTotalKey(workspace, path2) {
+  return `paged:${workspace}:${datasetPathToString(path2)}#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 toFindQuery(query) {
+  const q = query;
+  if (q.type === "key") return { key: q.value };
+  if (q.type === "prefix") return { prefix: q.value };
+  const f2 = q.value;
+  const fields = [...f2.values];
+  return f2.prefix.type === "some" ? { fields, prefix: f2.prefix.value } : { fields };
+}
+class PagedRuntime extends TrackedChannelStore {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "api", null);
+    __publicField(this, "workspace", null);
+    // Compiled-handle cache (issue #106 perf): buildHandle compiles 2
+    // 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.
+    //
+    // 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
+    // redeployed dataset whose schema changed, inside a live session) must not
+    // hand back the handle compiled against the old type. Structural key for
+    // the same reason `bind-runtime` uses one: every bind builds a fresh
+    // `EastTypeValue` from IR, so a by-identity cache would miss every render.
+    __publicField(this, "handleCache", new SortedMap(
+      void 0,
+      compareFor(EastTypeType)
+    ));
+    /** 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());
+  }
+  /** Monotonic clock seam so tests can drive the retry gate. */
+  now() {
+    return Date.now();
+  }
+  createEntry() {
+    return { status: "idle", launchSeq: 0 };
+  }
+  // ----- wiring ----------------------------------------------------------
+  /** Install the API adapter + workspace — called by the React provider
+   *  (or a test/showcase harness) before any handle is used. */
+  initialize(api3, workspace) {
+    this.api = api3;
+    this.workspace = workspace;
+  }
+  /** Tear down the adapter and all window state. */
+  clear() {
+    this.api = null;
+    this.workspace = null;
+    this.clearChannels();
+    this.handleCache.clear();
+    this.loadedWindows.clear();
+  }
+  resolveWorkspace() {
+    if (!this.workspace) {
+      throw new Error(
+        "Data.bindPaged: no paging service — a paged source is served BY THE SERVER (datasetGetPage), so it resolves only inside a live workspace. Render this component against a deployed workspace, or bind the whole value with Data.bind."
+      );
+    }
+    return this.workspace;
+  }
+  // ----- window loading --------------------------------------------------
+  /** 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. */
+  touchWindow(key) {
+    this.loadedWindows.delete(key);
+    this.loadedWindows.set(key, true);
+    if (this.loadedWindows.size <= MAX_RETAINED_WINDOWS) return;
+    for (const candidate of [...this.loadedWindows.keys()]) {
+      if (this.loadedWindows.size <= MAX_RETAINED_WINDOWS) break;
+      if (this.isTracked(candidate)) continue;
+      const entry = this.entries.get(candidate);
+      if (entry === void 0 || entry.status !== "loaded") continue;
+      this.loadedWindows.delete(candidate);
+      entry.status = "idle";
+      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;
+    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;
+        });
+        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
+        );
+        return;
+      }
+      let decoded;
+      try {
+        decoded = decodeBeast2For(sourceType)(page.data);
+      } catch (err) {
+        settle((e3) => {
+          e3.status = "failed";
+          e3.failedAtMs = this.now();
+        });
+        console.error(`Data.bindPaged: decode failed for ${key}:`, err);
+        return;
+      }
+      settle((e3) => {
+        e3.status = "loaded";
+        e3.window = decoded;
+        e3.total = page.totalElements;
+      });
+      this.touchWindow(key);
+      const totalKey = pagedTotalKey(workspace, path2);
+      const totalEntry = this.entry(totalKey);
+      if (totalEntry.total !== page.totalElements) {
+        totalEntry.total = page.totalElements;
+        totalEntry.status = "loaded";
+        this.notify(totalKey);
+      }
+    })();
+  }
+  /**
+   * 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;
+    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;
+      }
+      try {
+        const range = await api3.findKey(workspace, path2, query);
+        settle((e3) => {
+          e3.status = "loaded";
+          e3.range = range;
+        });
+      } catch (err) {
+        const permanent = isPermanentPageError(err);
+        settle((e3) => {
+          e3.status = "failed";
+          e3.failedAtMs = this.now();
+          e3.permanent = permanent;
+        });
+        console.error(`Data.bindPaged: key search failed for ${key}:`, err);
+      }
+    })();
+  }
+  /**
+   * The low-level primitives backing handle methods, bound to THIS runtime.
+   * Registered globally (extension registry) and included by the scoped
+   * platform (e3 `ui()` tasks) so a decoded handle re-binds to whatever
+   * runtime resolves the primitives on the decode side.
+   */
+  buildPrimitives() {
+    return [
+      DataPagedPrimitives.page.implement((sourceType) => (pathArg, offsetArg, limitArg) => {
+        const workspace = this.resolveWorkspace();
+        const path2 = pathArg;
+        const offset = Number(offsetArg);
+        const limit2 = Number(limitArg);
+        const key = pagedWindowKey(workspace, path2, offset, limit2);
+        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 variant("some", entry.window);
+        }
+        return variant("none", null);
+      }),
+      DataPagedPrimitives.total.implement((_sourceType) => (pathArg) => {
+        const workspace = this.resolveWorkspace();
+        const key = pagedTotalKey(workspace, pathArg);
+        this.track(key);
+        const entry = this.entry(key);
+        return entry.total !== void 0 ? variant("some", BigInt(entry.total)) : variant("none", null);
+      }),
+      DataPagedPrimitives.seek.implement((_sourceType) => (pathArg, queryArg) => {
+        const workspace = this.resolveWorkspace();
+        const path2 = pathArg;
+        const query = toFindQuery(queryArg);
+        const key = pagedSeekKey(workspace, path2, query);
+        this.track(key);
+        this.ensureSeek(workspace, path2, query, key);
+        const entry = this.entry(key);
+        if (entry.status !== "loaded" || entry.range === void 0) return none$1;
+        const r2 = entry.range;
+        return some({ found: r2.found, row: BigInt(r2.row), count: BigInt(r2.count) });
+      })
+    ];
+  }
+  /**
+   * 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).
+   */
+  buildHandle(sourceType, path2) {
+    const pathKey = datasetPathToString(path2);
+    let byPath = this.handleCache.get(sourceType);
+    if (byPath) {
+      const hit = byPath.get(pathKey);
+      if (hit) return hit;
+    } else {
+      byPath = /* @__PURE__ */ new Map();
+      this.handleCache.set(sourceType, byPath);
+    }
+    const T2 = fromEastTypeValue(sourceType);
+    const pathExpr = East.value(path2, TreePathType);
+    const platform = this.buildPrimitives();
+    const { page, total } = 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,
+      page: East.compile(
+        East.function([IntegerType, IntegerType], OptionType(T2), ($3, offset, limit2) => {
+          $3.return(page([T2], pathExpr, offset, limit2));
+        }),
+        platform
+      ),
+      total: East.compile(
+        East.function([], OptionType(IntegerType), ($3) => {
+          $3.return(total([T2], pathExpr));
+        }),
+        platform
+      ),
+      // Key search is a KEY-ORDER capability: Set/Dict element windows
+      // ride the canonical East key order, so a key locates in O(log
+      // 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, platform)
+    };
+    byPath.set(pathKey, 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. */
+  buildPlatform(allowed) {
+    return 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);
+      }
+    );
+  }
+}
+const defaultPagedRuntime = new PagedRuntime();
+function initializePagedApi(api3, workspace) {
+  defaultPagedRuntime.initialize(api3, workspace);
+}
+function clearPagedApi() {
+  defaultPagedRuntime.clear();
+}
+const PagedPlatform = [
+  defaultPagedRuntime.buildPlatform(null),
+  ...defaultPagedRuntime.buildPrimitives()
+];
+function createScopedPagedPlatform(pages) {
+  const allowed = new Set(pages.map((p2) => datasetPathToString(p2)));
+  return [
+    defaultPagedRuntime.buildPlatform(allowed),
+    ...defaultPagedRuntime.buildPrimitives()
+  ];
+}
+registerReactiveTracker({
+  id: "data-bind-paged",
+  enableTracking: () => defaultPagedRuntime.enableTracking(),
+  disableTracking: () => defaultPagedRuntime.disableTracking(),
+  getStore: () => ({
+    subscribe: (key, cb) => defaultPagedRuntime.subscribe(key, cb),
+    getKeyVersion: (key) => defaultPagedRuntime.getKeyVersion(key)
+  })
+});
+registerPlatformImplementation(PagedPlatform);
 function createDefaultFunctionApi(apiUrl, repo, getToken) {
   const opts = () => ({ token: getToken() });
   return {
@@ -8299,6 +8699,14 @@ function ReactiveDatasetProvider({
       );
     }
   }, [e3.apiUrl, e3.repo, e3.workspace]);
+  useMemo(() => {
+    if (e3.workspace !== void 0) {
+      initializePagedApi(
+        createDefaultPagedApi(e3.apiUrl, e3.repo ?? "default", () => tokenRef.current),
+        e3.workspace
+      );
+    }
+  }, [e3.apiUrl, e3.repo, e3.workspace]);
   useMemo(() => {
     if (e3.workspace !== void 0) {
       initializeRecordApi(
@@ -8313,6 +8721,7 @@ function ReactiveDatasetProvider({
       const ws = cache3.getConfig().workspace;
       clearReactiveDatasetCache();
       clearFunctionApi();
+      clearPagedApi();
       clearRecordApi();
       cache3.destroy();
       if (ws) clearBindingRegistry(ws);
@@ -9272,6 +9681,7 @@ const EastChakraDiff = memo(function EastChakraDiff2({ value }) {
   const es = eyebrow({});
   const commit = useSlotRecipe({ key: "commitBar" });
   const cs = commit({});
+  const btn = useRecipe({ key: "button" });
   const allDatasetPaths = useMemo(() => {
     const paths = [];
     for (const b2 of irBindings) {
@@ -9573,12 +9983,12 @@ const EastChakraDiff = memo(function EastChakraDiff2({ value }) {
               " · clean merge"
             ] }) }),
             /* @__PURE__ */ jsxs(Box, { css: cs.btnRow, children: [
-              /* @__PURE__ */ jsx$1(Box, { as: "button", css: cs.btnDanger, onClick: onDiscardAll, children: "Discard all" }),
+              /* @__PURE__ */ jsx$1(Box, { as: "button", css: btn({ variant: "danger", size: "md" }), onClick: onDiscardAll, children: "Discard all" }),
               /* @__PURE__ */ jsx$1(
                 Box,
                 {
                   as: "button",
-                  css: cs.btnPrimary,
+                  css: btn({ variant: "solid", size: "md" }),
                   "aria-disabled": applyDisabled,
                   onClick: applyDisabled ? void 0 : onApply,
                   title: hasStaleLeaves ? "Discard or re-edit the stale changes before applying." : void 0,
@@ -63771,6 +64181,7 @@ const defaultPlatformImplementations = [
   ...ShareImpl,
   ...DecisionBindPlatform,
   ...BindPlatform,
+  ...PagedPlatform,
   ...FuncPlatform,
   ...RecordPlatform
 ];
@@ -63988,271 +64399,6 @@ class ErrorBoundary extends Component {
     return this.props.children;
   }
 }
-const FIND_DEBOUNCE_MS = 250;
-const POPUP_LIMIT = 20;
-function structFields(keyType) {
-  if (keyType.type !== "Struct") return null;
-  const fields = keyType.value;
-  return fields.length > 0 ? fields : null;
-}
-function splitTopLevel(text) {
-  const parts = [];
-  let current = "";
-  let inString = false;
-  let depth = 0;
-  for (let i = 0; i < text.length; i++) {
-    const ch = text[i];
-    if (inString) {
-      current += ch;
-      if (ch === "\\" && i + 1 < text.length) {
-        current += text[i + 1];
-        i++;
-      } else if (ch === '"') {
-        inString = false;
-      }
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-      current += ch;
-    } else if (ch === "(" || ch === "[" || ch === "{") {
-      depth++;
-      current += ch;
-    } else if (ch === ")" || ch === "]" || ch === "}") {
-      depth--;
-      current += ch;
-    } else if (ch === "," && depth === 0) {
-      parts.push(current);
-      current = "";
-    } else {
-      current += ch;
-    }
-  }
-  parts.push(current);
-  return parts;
-}
-function keySignature(keyType) {
-  const fields = structFields(keyType);
-  if (fields === null) return keyType.type;
-  return `(${fields.map((f2) => `${f2.name}: ${f2.type.type}`).join(", ")})`;
-}
-function parseKeyInput(keyType, text) {
-  const fields = structFields(keyType);
-  if (fields === null) {
-    if (keyType.type === "String") return { kind: "query", query: { prefix: text } };
-    const parsed = parseFor(keyType)(text);
-    if (!parsed.success) return { kind: "hint", hint: `Key is ${keyType.type}` };
-    return { kind: "query", query: { key: printFor(keyType)(parsed.value) } };
-  }
-  if (text.trimStart().startsWith("(")) {
-    const parsed = parseFor(keyType)(text);
-    if (!parsed.success) return { kind: "hint", hint: `Key is ${keySignature(keyType)}` };
-    return { kind: "query", query: { key: printFor(keyType)(parsed.value) } };
-  }
-  const segments = splitTopLevel(text);
-  if (segments.length > fields.length) {
-    return { kind: "hint", hint: `Key is ${keySignature(keyType)}` };
-  }
-  const exact = [];
-  for (let i = 0; i < segments.length; i++) {
-    const field = fields[i];
-    const raw = segments[i].trim();
-    const isLast = i === segments.length - 1;
-    if (isLast && raw === "" && i > 0) {
-      return { kind: "query", query: { fields: exact } };
-    }
-    if (field.type.type === "String" && !raw.startsWith('"')) {
-      if (isLast) {
-        return exact.length === 0 ? { kind: "query", query: { prefix: raw } } : { kind: "query", query: { fields: exact, prefix: raw } };
-      }
-      exact.push(printFor(StringType)(raw));
-      continue;
-    }
-    const parsed = parseFor(field.type)(raw);
-    if (!parsed.success) {
-      return { kind: "hint", hint: `${field.name} is ${field.type.type} — key is ${keySignature(keyType)}` };
-    }
-    exact.push(printFor(field.type)(parsed.value));
-  }
-  return { kind: "query", query: { fields: exact } };
-}
-const MATCH_NOTHING = { lower: () => false, upper: () => false };
-function keyRangePredicates(keyType, query) {
-  if ("key" in query) return null;
-  if (keyType.type === "Struct") {
-    const meta3 = keyType.value;
-    const literals = "fields" in query ? query.fields : [];
-    if (literals.length > meta3.length) return MATCH_NOTHING;
-    const values = [];
-    for (let j2 = 0; j2 < literals.length; j2++) {
-      const parsed = parseFor(meta3[j2].type)(literals[j2]);
-      if (!parsed.success) return MATCH_NOTHING;
-      values.push(parsed.value);
-    }
-    const cmps = meta3.map((f2) => compareFor(f2.type));
-    const lead = (k2) => {
-      for (let j2 = 0; j2 < values.length; j2++) {
-        const c2 = cmps[j2](k2[meta3[j2].name], values[j2]);
-        if (c2 !== 0) return c2;
-      }
-      return 0;
-    };
-    const prefix22 = query.prefix;
-    if (prefix22 === void 0) {
-      return { lower: (k2) => lead(k2) >= 0, upper: (k2) => lead(k2) > 0 };
-    }
-    const prefixIdx = values.length;
-    if (prefixIdx >= meta3.length || meta3[prefixIdx].type.type !== "String") return MATCH_NOTHING;
-    const prefixName = meta3[prefixIdx].name;
-    const prefixCmp = cmps[prefixIdx];
-    return {
-      lower: (k2) => {
-        const c2 = lead(k2);
-        return c2 !== 0 ? c2 > 0 : prefixCmp(k2[prefixName], prefix22) >= 0;
-      },
-      upper: (k2) => {
-        const c2 = lead(k2);
-        if (c2 !== 0) return c2 > 0;
-        const field = k2[prefixName];
-        return prefixCmp(field, prefix22) > 0 && !field.startsWith(prefix22);
-      }
-    };
-  }
-  if (!("prefix" in query) || query.prefix === void 0 || keyType.type !== "String") return MATCH_NOTHING;
-  const prefix2 = query.prefix;
-  const cmp = compareFor(keyType);
-  return {
-    lower: (k2) => cmp(k2, prefix2) >= 0,
-    upper: (k2) => cmp(k2, prefix2) > 0 && !k2.startsWith(prefix2)
-  };
-}
-const DatasetKeySearch = memo(function DatasetKeySearch2({ keyType, onFind, onListRange, onJump, onClear }) {
-  const [range, setRange] = useState(null);
-  const [items, setItems] = useState([]);
-  const [activeIdx, setActiveIdx] = useState(-1);
-  const [hint, setHint] = useState(null);
-  const [resetSeq, setResetSeq] = useState(0);
-  const debounceRef = useRef(void 0);
-  const findSeqRef = useRef(0);
-  useEffect(() => () => clearTimeout(debounceRef.current), []);
-  const runFind = useCallback((query) => {
-    const seq = ++findSeqRef.current;
-    void (async () => {
-      try {
-        const result = await onFind(query);
-        if (seq !== findSeqRef.current) return;
-        setRange(result);
-        setActiveIdx(-1);
-        if (result.found) {
-          const labels = await onListRange(result.row, Math.min(POPUP_LIMIT, result.count));
-          if (seq !== findSeqRef.current) return;
-          setItems(labels.map((label, i) => ({ row: result.row + i, label })));
-        } else {
-          setItems([]);
-        }
-      } catch {
-        if (seq !== findSeqRef.current) return;
-        setRange(null);
-        setItems([]);
-      }
-    })();
-  }, [onFind, onListRange]);
-  const resetQueryState = useCallback(() => {
-    clearTimeout(debounceRef.current);
-    findSeqRef.current++;
-    setRange(null);
-    setItems([]);
-    setActiveIdx(-1);
-    setHint(null);
-  }, []);
-  const handleInput = useCallback((text) => {
-    clearTimeout(debounceRef.current);
-    if (text === "") {
-      resetQueryState();
-      onClear == null ? void 0 : onClear();
-      return;
-    }
-    const parsed = parseKeyInput(keyType, text);
-    if (parsed.kind === "hint") {
-      findSeqRef.current++;
-      setRange(null);
-      setItems([]);
-      setActiveIdx(-1);
-      setHint(parsed.hint);
-      return;
-    }
-    setHint(null);
-    debounceRef.current = setTimeout(() => runFind(parsed.query), FIND_DEBOUNCE_MS);
-  }, [keyType, runFind, resetQueryState, onClear]);
-  const clearSearch = useCallback(() => {
-    resetQueryState();
-    setResetSeq((s2) => s2 + 1);
-    onClear == null ? void 0 : onClear();
-  }, [resetQueryState, onClear]);
-  const commit = useCallback((row) => {
-    onJump(row);
-    if (range !== null) setActiveIdx(row - range.row);
-  }, [onJump, range]);
-  const step3 = useCallback((delta) => {
-    if (range === null || !range.found) return;
-    const next2 = Math.max(0, Math.min(range.count - 1, (activeIdx === -1 ? 0 : activeIdx) + delta));
-    commit(range.row + next2);
-  }, [range, activeIdx, commit]);
-  const onKeyDownCapture = useCallback((e3) => {
-    if (e3.key !== "Enter" || range === null || !range.found) return;
-    if (document.querySelector('[data-scope="combobox"][data-part="content"] [data-highlighted]') !== null) return;
-    commit(range.row + Math.max(0, activeIdx));
-  }, [range, activeIdx, commit]);
-  const placeholder = useMemo(() => {
-    const fields = structFields(keyType);
-    if (fields !== null) return `Search keys (${fields.map((f2) => f2.name).join(", ")})`;
-    return keyType.type === "String" ? "Search keys" : `Find key (${keyType.type})`;
-  }, [keyType]);
-  const payload = useMemo(() => ({
-    value: none$1,
-    items: items.map((it) => ({ value: String(it.row), label: it.label, disabled: none$1 })),
-    placeholder: some(placeholder),
-    multiple: none$1,
-    disabled: none$1,
-    allowCustomValue: some(true),
-    onChange: some((v3) => commit(Number(v3))),
-    onChangeMultiple: none$1,
-    onInputValueChange: some(handleInput),
-    onOpenChange: none$1,
-    style: some({ size: some(variant("xs", null)), color: none$1, background: none$1, borderColor: none$1 })
-  }), [items, placeholder, commit, handleInput]);
-  const status = hint !== null ? hint : range === null ? null : !range.found ? "No matches" : activeIdx === -1 ? `${range.count.toLocaleString()} ${range.count === 1 ? "match" : "matches"}` : `${(activeIdx + 1).toLocaleString()} of ${range.count.toLocaleString()}`;
-  const canStep = range !== null && range.found && range.count > 1;
-  return /* @__PURE__ */ jsxs(Flex, { gap: 1, align: "center", minW: "0", onKeyDownCapture, "data-part": "dataset-key-search", children: [
-    /* @__PURE__ */ jsx$1(Flex, { width: `min(${placeholder.length + 10}ch, 40rem)`, minW: "12rem", flexShrink: 1, children: /* @__PURE__ */ jsx$1(EastChakraCombobox, { value: payload, selectionBehavior: "preserve" }, resetSeq) }),
-    status !== null && /* @__PURE__ */ jsx$1(Text, { fontSize: "xs", color: "fg.muted", whiteSpace: "nowrap", children: status }),
-    canStep && /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsx$1(
-        IconButton,
-        {
-          "aria-label": "Previous match",
-          size: "2xs",
-          variant: "ghost",
-          disabled: activeIdx <= 0,
-          onClick: () => step3(-1),
-          children: /* @__PURE__ */ jsx$1(FontAwesomeIcon, { icon: faChevronUp })
-        }
-      ),
-      /* @__PURE__ */ jsx$1(
-        IconButton,
-        {
-          "aria-label": "Next match",
-          size: "2xs",
-          variant: "ghost",
-          disabled: activeIdx >= range.count - 1,
-          onClick: () => step3(1),
-          children: /* @__PURE__ */ jsx$1(FontAwesomeIcon, { icon: faChevronDown })
-        }
-      )
-    ] }),
-    (range !== null || hint !== null) && /* @__PURE__ */ jsx$1(IconButton, { "aria-label": "Clear search", size: "2xs", variant: "ghost", onClick: clearSearch, children: /* @__PURE__ */ jsx$1(FontAwesomeIcon, { icon: faXmark }) })
-  ] });
-});
 function pagingDebug(...args) {
   try {
     if (typeof localStorage === "undefined") return;
@@ -64684,7 +64830,7 @@ const UITaskPreview = memo(function UITaskPreview2({
   const manifest = useMemo(() => {
     if (!details || !isUI) return null;
     const meta3 = getTaskMetadata(details);
-    return meta3 ? decodeManifest(meta3) : { paths: [], functions: [], records: [] };
+    return meta3 ? decodeManifest(meta3) : { paths: [], functions: [], records: [], pages: [] };
   }, [details, isUI]);
   const outputPath = details ? treePathToString$1(details.output) : null;
   const preloads = useMemo(
@@ -64708,6 +64854,7 @@ const UITaskPreview = memo(function UITaskPreview2({
       ...ShareImpl,
       ...DecisionBindPlatform,
       ...createScopedBindPlatform(manifest),
+      ...createScopedPagedPlatform(manifest.pages),
       ...createScopedFuncPlatform(manifest.functions),
       ...createScopedRecordPlatform(manifest.records)
     ] : void 0,
@@ -65621,7 +65768,7 @@ export {
   BindPlatform,
   BindRuntime,
   DataTaskPreview,
-  DatasetKeySearch,
+  DatasetKeySearch2 as DatasetKeySearch,
   DatasetPreview,
   E3Provider,
   EastChakraDecisionJournal,
@@ -65636,6 +65783,8 @@ export {
   IndexedDBStagedAdapter,
   InputPreview,
   MemoryStagedAdapter,
+  PagedPlatform,
+  PagedRuntime,
   ReactiveDatasetCache,
   ReactiveDatasetLoader,
   ReactiveDatasetProvider,
@@ -65649,6 +65798,7 @@ export {
   awaitPendingWrites,
   clearBindingRegistry,
   clearFunctionApi,
+  clearPagedApi,
   clearPendingWrites,
   clearReactiveDatasetCache,
   clearReactiveDatasetListCache,
@@ -65656,17 +65806,20 @@ export {
   clearStagedStoreSingleton,
   createDefaultDatasetApi,
   createDefaultFunctionApi,
+  createDefaultPagedApi,
   createDefaultRecordApi,
   createInMemoryFunctionApi,
   createInMemoryRecordApi,
   createReactiveDatasetCache,
   createScopedBindPlatform,
   createScopedFuncPlatform,
+  createScopedPagedPlatform,
   createScopedRecordPlatform,
   datasetCacheKey,
   datasetPathToString,
   defaultBindRuntime,
   defaultFuncRuntime,
+  defaultPagedRuntime,
   defaultRecordRuntime,
   disableBindingTracking,
   enableBindingTracking,
@@ -65679,11 +65832,14 @@ export {
   getTaskKind,
   getTaskMetadata,
   initializeFunctionApi,
+  initializePagedApi,
   initializeReactiveDatasetCache,
   initializeRecordApi,
   initializeStagedStore,
   isBindingTracking,
   onWriteError,
+  pagedTotalKey,
+  pagedWindowKey,
   preloadReactiveDatasetList,
   realClock,
   recordChannelKey,