@elaraai/e3-ui-components 1.0.67 → 1.0.69

package/dist/index.cjs

@@ -26,6 +26,7 @@ const internal$1 = require("@elaraai/e3-ui/internal");
 const platform = require("@elaraai/east-ui-components/platform");
 const e3Types = require("@elaraai/e3-types");
 const e3ApiClient = require("@elaraai/e3-api-client");
+const eastUi = require("@elaraai/east-ui");
 const jsxRuntime = require("react/jsx-runtime");
 const React = require("react");
 const react = require("@chakra-ui/react");
@@ -33,7 +34,6 @@ const eastUiComponents = require("@elaraai/east-ui-components");
 const reactDom = require("react-dom");
 const internal$2 = require("@elaraai/east-ui/internal");
 const reactQuery = require("@tanstack/react-query");
-const eastUi = require("@elaraai/east-ui");
 const reactVirtual = require("@tanstack/react-virtual");
 function _interopNamespaceDefault(e3) {
   const n2 = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
@@ -3611,6 +3611,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) {
@@ -3692,6 +3700,397 @@ class TrackedChannelStore {
     this.keyVersions.clear();
   }
 }
+function createDefaultPagedApi(apiUrl, repo, getToken) {
+  const opts = () => ({ token: getToken() });
+  return {
+    async getPage(workspace, path2, window3) {
+      return e3ApiClient.datasetGetPage(apiUrl, repo, workspace, path2, window3, opts());
+    },
+    async findKey(workspace, path2, query) {
+      return e3ApiClient.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, platform2) {
+  if (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));
+    }),
+    platform2
+  ));
+}
+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 east.SortedMap(
+      void 0,
+      east.compareFor(internal.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 = east.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 [
+      internal$1.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 east.variant("some", entry.window);
+        }
+        return east.variant("none", null);
+      }),
+      internal$1.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 ? east.variant("some", BigInt(entry.total)) : east.variant("none", null);
+      }),
+      internal$1.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 east.none;
+        const r2 = entry.range;
+        return east.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 = east.fromEastTypeValue(sourceType);
+    const pathExpr = east.East.value(path2, e3Types.TreePathType);
+    const platform2 = this.buildPrimitives();
+    const { page, total } = 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,
+      page: east.East.compile(
+        east.East.function([east.IntegerType, east.IntegerType], east.OptionType(T2), ($3, offset, limit2) => {
+          $3.return(page([T2], pathExpr, offset, limit2));
+        }),
+        platform2
+      ),
+      total: east.East.compile(
+        east.East.function([], east.OptionType(east.IntegerType), ($3) => {
+          $3.return(total([T2], pathExpr));
+        }),
+        platform2
+      ),
+      // 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, platform2)
+    };
+    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 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);
+      }
+    );
+  }
+}
+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()
+  ];
+}
+platform.registerReactiveTracker({
+  id: "data-bind-paged",
+  enableTracking: () => defaultPagedRuntime.enableTracking(),
+  disableTracking: () => defaultPagedRuntime.disableTracking(),
+  getStore: () => ({
+    subscribe: (key, cb) => defaultPagedRuntime.subscribe(key, cb),
+    getKeyVersion: (key) => defaultPagedRuntime.getKeyVersion(key)
+  })
+});
+platform.registerPlatformImplementation(PagedPlatform);
 function createDefaultFunctionApi(apiUrl, repo, getToken) {
   const opts = () => ({ token: getToken() });
   return {
@@ -8317,6 +8716,14 @@ function ReactiveDatasetProvider({
       );
     }
   }, [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(
@@ -8331,6 +8738,7 @@ function ReactiveDatasetProvider({
       const ws = cache3.getConfig().workspace;
       clearReactiveDatasetCache();
       clearFunctionApi();
+      clearPagedApi();
       clearRecordApi();
       cache3.destroy();
       if (ws) clearBindingRegistry(ws);
@@ -9290,6 +9698,7 @@ const EastChakraDiff = React.memo(function EastChakraDiff2({ value }) {
   const es = eyebrow({});
   const commit = react.useSlotRecipe({ key: "commitBar" });
   const cs = commit({});
+  const btn = react.useRecipe({ key: "button" });
   const allDatasetPaths = React.useMemo(() => {
     const paths = [];
     for (const b2 of irBindings) {
@@ -9591,12 +10000,12 @@ const EastChakraDiff = React.memo(function EastChakraDiff2({ value }) {
               " · clean merge"
             ] }) }),
             /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: cs.btnRow, children: [
-              /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "button", css: cs.btnDanger, onClick: onDiscardAll, children: "Discard all" }),
+              /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "button", css: btn({ variant: "danger", size: "md" }), onClick: onDiscardAll, children: "Discard all" }),
               /* @__PURE__ */ jsxRuntime.jsx(
                 react.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,
@@ -63789,6 +64198,7 @@ const defaultPlatformImplementations = [
   ...eastUiComponents.ShareImpl,
   ...DecisionBindPlatform,
   ...BindPlatform,
+  ...PagedPlatform,
   ...FuncPlatform,
   ...RecordPlatform
 ];
@@ -64006,271 +64416,6 @@ class ErrorBoundary extends React.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 = east.parseFor(keyType)(text);
-    if (!parsed.success) return { kind: "hint", hint: `Key is ${keyType.type}` };
-    return { kind: "query", query: { key: east.printFor(keyType)(parsed.value) } };
-  }
-  if (text.trimStart().startsWith("(")) {
-    const parsed = east.parseFor(keyType)(text);
-    if (!parsed.success) return { kind: "hint", hint: `Key is ${keySignature(keyType)}` };
-    return { kind: "query", query: { key: east.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(east.printFor(east.StringType)(raw));
-      continue;
-    }
-    const parsed = east.parseFor(field.type)(raw);
-    if (!parsed.success) {
-      return { kind: "hint", hint: `${field.name} is ${field.type.type} — key is ${keySignature(keyType)}` };
-    }
-    exact.push(east.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 = east.parseFor(meta3[j2].type)(literals[j2]);
-      if (!parsed.success) return MATCH_NOTHING;
-      values.push(parsed.value);
-    }
-    const cmps = meta3.map((f2) => east.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 = east.compareFor(keyType);
-  return {
-    lower: (k2) => cmp(k2, prefix2) >= 0,
-    upper: (k2) => cmp(k2, prefix2) > 0 && !k2.startsWith(prefix2)
-  };
-}
-const DatasetKeySearch = React.memo(function DatasetKeySearch2({ keyType, onFind, onListRange, onJump, onClear }) {
-  const [range, setRange] = React.useState(null);
-  const [items, setItems] = React.useState([]);
-  const [activeIdx, setActiveIdx] = React.useState(-1);
-  const [hint, setHint] = React.useState(null);
-  const [resetSeq, setResetSeq] = React.useState(0);
-  const debounceRef = React.useRef(void 0);
-  const findSeqRef = React.useRef(0);
-  React.useEffect(() => () => clearTimeout(debounceRef.current), []);
-  const runFind = React.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 = React.useCallback(() => {
-    clearTimeout(debounceRef.current);
-    findSeqRef.current++;
-    setRange(null);
-    setItems([]);
-    setActiveIdx(-1);
-    setHint(null);
-  }, []);
-  const handleInput = React.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 = React.useCallback(() => {
-    resetQueryState();
-    setResetSeq((s2) => s2 + 1);
-    onClear == null ? void 0 : onClear();
-  }, [resetQueryState, onClear]);
-  const commit = React.useCallback((row) => {
-    onJump(row);
-    if (range !== null) setActiveIdx(row - range.row);
-  }, [onJump, range]);
-  const step3 = React.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 = React.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 = React.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 = React.useMemo(() => ({
-    value: east.none,
-    items: items.map((it) => ({ value: String(it.row), label: it.label, disabled: east.none })),
-    placeholder: east.some(placeholder),
-    multiple: east.none,
-    disabled: east.none,
-    allowCustomValue: east.some(true),
-    onChange: east.some((v3) => commit(Number(v3))),
-    onChangeMultiple: east.none,
-    onInputValueChange: east.some(handleInput),
-    onOpenChange: east.none,
-    style: east.some({ size: east.some(east.variant("xs", null)), color: east.none, background: east.none, borderColor: east.none })
-  }), [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__ */ jsxRuntime.jsxs(react.Flex, { gap: 1, align: "center", minW: "0", onKeyDownCapture, "data-part": "dataset-key-search", children: [
-    /* @__PURE__ */ jsxRuntime.jsx(react.Flex, { width: `min(${placeholder.length + 10}ch, 40rem)`, minW: "12rem", flexShrink: 1, children: /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraCombobox, { value: payload, selectionBehavior: "preserve" }, resetSeq) }),
-    status !== null && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "xs", color: "fg.muted", whiteSpace: "nowrap", children: status }),
-    canStep && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-      /* @__PURE__ */ jsxRuntime.jsx(
-        react.IconButton,
-        {
-          "aria-label": "Previous match",
-          size: "2xs",
-          variant: "ghost",
-          disabled: activeIdx <= 0,
-          onClick: () => step3(-1),
-          children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faChevronUp })
-        }
-      ),
-      /* @__PURE__ */ jsxRuntime.jsx(
-        react.IconButton,
-        {
-          "aria-label": "Next match",
-          size: "2xs",
-          variant: "ghost",
-          disabled: activeIdx >= range.count - 1,
-          onClick: () => step3(1),
-          children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faChevronDown })
-        }
-      )
-    ] }),
-    (range !== null || hint !== null) && /* @__PURE__ */ jsxRuntime.jsx(react.IconButton, { "aria-label": "Clear search", size: "2xs", variant: "ghost", onClick: clearSearch, children: /* @__PURE__ */ jsxRuntime.jsx(FontAwesomeIcon, { icon: faXmark }) })
-  ] });
-});
 function pagingDebug(...args) {
   try {
     if (typeof localStorage === "undefined") return;
@@ -64463,7 +64608,7 @@ const PagedDatasetPreview = React.memo(function PagedDatasetPreview2({
       ] }),
       loadingCount > 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "xs", color: "fg.muted", children: "Loading…" }),
       keyType !== null && /* @__PURE__ */ jsxRuntime.jsx(
-        DatasetKeySearch,
+        eastUiComponents.DatasetKeySearch,
         {
           keyType,
           onFind: onFindKey,
@@ -64551,7 +64696,7 @@ const DatasetPreview = React.memo(function DatasetPreview2({
   }, [decoded]);
   const onFindInline = React.useCallback(async (query) => {
     if (inlineKeys === null || keyType === null) return { found: false, row: 0, count: 0 };
-    const range = keyRangePredicates(keyType, query);
+    const range = eastUiComponents.keyRangePredicates(keyType, query);
     if (range === null) {
       const parsed = east.parseFor(keyType)(query.key);
       if (!parsed.success) return { found: false, row: 0, count: 0 };
@@ -64630,7 +64775,7 @@ const DatasetPreview = React.memo(function DatasetPreview2({
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Flex, { direction: "column", height: "100%", overflow: "hidden", children: [
     /* @__PURE__ */ jsxRuntime.jsxs(react.Flex, { px: 4, py: 2, gap: 2, align: "center", flexShrink: 0, borderBottom: "1px solid", borderColor: "border.subtle", children: [
       keyType !== null && inlineKeys !== null && /* @__PURE__ */ jsxRuntime.jsx(
-        DatasetKeySearch,
+        eastUiComponents.DatasetKeySearch,
         {
           keyType,
           onFind: onFindInline,
@@ -64702,7 +64847,7 @@ const UITaskPreview = React.memo(function UITaskPreview2({
   const manifest = React.useMemo(() => {
     if (!details || !isUI) return null;
     const meta3 = getTaskMetadata(details);
-    return meta3 ? internal$1.decodeManifest(meta3) : { paths: [], functions: [], records: [] };
+    return meta3 ? internal$1.decodeManifest(meta3) : { paths: [], functions: [], records: [], pages: [] };
   }, [details, isUI]);
   const outputPath = details ? treePathToString$1(details.output) : null;
   const preloads = React.useMemo(
@@ -64726,6 +64871,7 @@ const UITaskPreview = React.memo(function UITaskPreview2({
       ...eastUiComponents.ShareImpl,
       ...DecisionBindPlatform,
       ...createScopedBindPlatform(manifest),
+      ...createScopedPagedPlatform(manifest.pages),
       ...createScopedFuncPlatform(manifest.functions),
       ...createScopedRecordPlatform(manifest.records)
     ] : void 0,
@@ -65635,10 +65781,13 @@ function EastValueViewer({ type, value }) {
     }
   );
 }
+Object.defineProperty(exports, "DatasetKeySearch", {
+  enumerable: true,
+  get: () => eastUiComponents.DatasetKeySearch
+});
 exports.BindPlatform = BindPlatform;
 exports.BindRuntime = BindRuntime;
 exports.DataTaskPreview = DataTaskPreview;
-exports.DatasetKeySearch = DatasetKeySearch;
 exports.DatasetPreview = DatasetPreview;
 exports.E3Provider = E3Provider;
 exports.EastChakraDecisionJournal = EastChakraDecisionJournal;
@@ -65653,6 +65802,8 @@ exports.FuncRuntime = FuncRuntime;
 exports.IndexedDBStagedAdapter = IndexedDBStagedAdapter;
 exports.InputPreview = InputPreview;
 exports.MemoryStagedAdapter = MemoryStagedAdapter;
+exports.PagedPlatform = PagedPlatform;
+exports.PagedRuntime = PagedRuntime;
 exports.ReactiveDatasetCache = ReactiveDatasetCache;
 exports.ReactiveDatasetLoader = ReactiveDatasetLoader;
 exports.ReactiveDatasetProvider = ReactiveDatasetProvider;
@@ -65666,6 +65817,7 @@ exports.VirtualizedLogViewer = VirtualizedLogViewer;
 exports.awaitPendingWrites = awaitPendingWrites;
 exports.clearBindingRegistry = clearBindingRegistry;
 exports.clearFunctionApi = clearFunctionApi;
+exports.clearPagedApi = clearPagedApi;
 exports.clearPendingWrites = clearPendingWrites;
 exports.clearReactiveDatasetCache = clearReactiveDatasetCache;
 exports.clearReactiveDatasetListCache = clearReactiveDatasetListCache;
@@ -65673,17 +65825,20 @@ exports.clearRecordApi = clearRecordApi;
 exports.clearStagedStoreSingleton = clearStagedStoreSingleton;
 exports.createDefaultDatasetApi = createDefaultDatasetApi;
 exports.createDefaultFunctionApi = createDefaultFunctionApi;
+exports.createDefaultPagedApi = createDefaultPagedApi;
 exports.createDefaultRecordApi = createDefaultRecordApi;
 exports.createInMemoryFunctionApi = createInMemoryFunctionApi;
 exports.createInMemoryRecordApi = createInMemoryRecordApi;
 exports.createReactiveDatasetCache = createReactiveDatasetCache;
 exports.createScopedBindPlatform = createScopedBindPlatform;
 exports.createScopedFuncPlatform = createScopedFuncPlatform;
+exports.createScopedPagedPlatform = createScopedPagedPlatform;
 exports.createScopedRecordPlatform = createScopedRecordPlatform;
 exports.datasetCacheKey = datasetCacheKey;
 exports.datasetPathToString = datasetPathToString;
 exports.defaultBindRuntime = defaultBindRuntime;
 exports.defaultFuncRuntime = defaultFuncRuntime;
+exports.defaultPagedRuntime = defaultPagedRuntime;
 exports.defaultRecordRuntime = defaultRecordRuntime;
 exports.disableBindingTracking = disableBindingTracking;
 exports.enableBindingTracking = enableBindingTracking;
@@ -65696,11 +65851,14 @@ exports.getStagedStore = getStagedStore;
 exports.getTaskKind = getTaskKind;
 exports.getTaskMetadata = getTaskMetadata;
 exports.initializeFunctionApi = initializeFunctionApi;
+exports.initializePagedApi = initializePagedApi;
 exports.initializeReactiveDatasetCache = initializeReactiveDatasetCache;
 exports.initializeRecordApi = initializeRecordApi;
 exports.initializeStagedStore = initializeStagedStore;
 exports.isBindingTracking = isBindingTracking;
 exports.onWriteError = onWriteError;
+exports.pagedTotalKey = pagedTotalKey;
+exports.pagedWindowKey = pagedWindowKey;
 exports.preloadReactiveDatasetList = preloadReactiveDatasetList;
 exports.realClock = realClock;
 exports.recordChannelKey = recordChannelKey;