@elaraai/e3-ui-components 1.0.13 → 1.0.14

package/dist/index.js

@@ -18,11 +18,11 @@ 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, EastError, ConflictError, equalFor, SortedMap, toEastTypeValue, PatchType, diffFor, applyFor, encodeBeast2For, decodeBeast2For, BlobType, compareFor, walkPatch, pathToString, pathDisplay, printFor, isVariant, prunePatchFor, detectConflictsFor, mergeWithResolutionsFor, validatePatchFor, none as none$1, some, fromEastTypeValue, OptionType, StringType } from "@elaraai/east";
+import { variant, EastError, ConflictError, equalFor, SortedMap, toEastTypeValue, PatchType, diffFor, applyFor, encodeBeast2For, decodeBeast2For, BlobType, compareFor, none as none$1, some, walkPatch, pathToString, pathDisplay, printFor, isVariant, prunePatchFor, detectConflictsFor, mergeWithResolutionsFor, validatePatchFor, fromEastTypeValue, OptionType, StringType } from "@elaraai/east";
 import { EastTypeType } from "@elaraai/east/internal";
-import { bindPlatformFn, funcBindPlatformFn, Diff, Ontology, FuncBindHandleType, Experiment, decisionBindPlatformFn, DecisionQueue, DecisionJournal, decodeManifest } from "@elaraai/e3-ui/internal";
+import { bindPlatformFn, funcBindPlatformFn, recordBindPlatformFn, Diff, Ontology, FuncBindHandleType, Experiment, decisionBindPlatformFn, DecisionQueue, DecisionJournal, decodeManifest } from "@elaraai/e3-ui/internal";
 import { registerReactiveTracker, registerPlatformImplementation } from "@elaraai/east-ui-components/platform";
-import { workspaceStatus, datasetListAt, datasetList, dataflowExecuteLaunch, datasetSet, datasetGet, workspaceFunctionCall, workspaceFunctionList, ApiError, 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 { workspaceStatus, datasetListAt, datasetList, dataflowExecuteLaunch, datasetSet, datasetGet, workspaceFunctionCall, workspaceFunctionList, workspaceRecordHistory, workspaceRecordMutate, workspaceRecordDescribe, ApiError, 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 { 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";
@@ -2088,9 +2088,6 @@ function datasetCacheKey(workspace, path2) {
   const pathStr = datasetPathToString(path2);
   return pathStr ? `${workspace}.${pathStr}` : workspace;
 }
-function toTreePath(path2) {
-  return path2;
-}
 class ReactiveDatasetCache {
   constructor(config2, api3, clock2 = realClock) {
     __publicField(this, "destroyed", false);
@@ -2212,7 +2209,7 @@ class ReactiveDatasetCache {
     const prevTail = this.writeChains.get(key) ?? Promise.resolve();
     const run = prevTail.then(async () => {
       try {
-        await this.api.set(workspace, toTreePath(path2), value);
+        await this.api.set(workspace, path2, value);
         if (this.destroyed) return;
         this.writeBaselines.set(key, {
           value,
@@ -2267,6 +2264,14 @@ class ReactiveDatasetCache {
     if (this.destroyed) return;
     await this.api.launchDataflow(workspace);
   }
+  /**
+   * Launch a workspace dataflow run without writing first. The standalone
+   * half of {@link writeAndStart}; see the interface doc for semantics.
+   */
+  async launchDataflow(workspace) {
+    if (this.destroyed) return;
+    await this.api.launchDataflow(workspace);
+  }
   /**
    * Preload a dataset into cache. Concurrent preloads of the same key
    * share one fetch (query-core dedup); a write racing the fetch cancels
@@ -2282,7 +2287,7 @@ class ReactiveDatasetCache {
       await this.client.fetchQuery({
         queryKey,
         queryFn: async () => {
-          const result = await this.fetchDataset(workspace, path2);
+          const result = await this.api.get(workspace, path2);
           fetchedHash = result.hash;
           return result.data;
         }
@@ -2298,14 +2303,11 @@ class ReactiveDatasetCache {
     this.knownHashes.set(key, fetchedHash);
     this.notifyChange(key);
   }
-  fetchDataset(workspace, path2) {
-    return this.api.get(workspace, toTreePath(path2));
-  }
   /**
    * List fields at a path. Empty path lists workspace root.
    */
   list(workspace, path2) {
-    return path2.length === 0 ? this.api.listRoot(workspace) : this.api.listAt(workspace, toTreePath(path2));
+    return path2.length === 0 ? this.api.listRoot(workspace) : this.api.listAt(workspace, path2);
   }
   /**
    * Set refetch interval for a dataset (polling).
@@ -2361,6 +2363,11 @@ class ReactiveDatasetCache {
       this.workspacePollers.delete(workspace);
     }
   }
+  refresh(workspace) {
+    if (this.destroyed) return Promise.resolve();
+    if (!this.workspacePollers.has(workspace)) return Promise.resolve();
+    return this.pollWorkspaceStatus(workspace);
+  }
   /**
    * Poll workspace status and reconcile the cache with the server.
    * Concurrent calls for the same workspace dedupe to a single fetch.
@@ -2425,7 +2432,7 @@ class ReactiveDatasetCache {
     if (pending.length === 0) return;
     const fetched = await Promise.allSettled(
       pending.map(
-        (p2) => p2.kind === "fetch" ? this.fetchDataset(workspace, p2.path).then((result) => ({ p: p2, result })) : Promise.resolve({ p: p2, result: null })
+        (p2) => p2.kind === "fetch" ? this.api.get(workspace, p2.path).then((result) => ({ p: p2, result })) : Promise.resolve({ p: p2, result: null })
       )
     );
     if (this.destroyed) return;
@@ -2608,6 +2615,9 @@ class IndexedDBStagedAdapter {
         req.onerror = () => reject2(req.error);
         req.onblocked = () => reject2(new Error("IndexedDB open blocked"));
       });
+      void this.dbPromise.catch(() => {
+        this.dbPromise = null;
+      });
     }
     return this.dbPromise;
   }
@@ -2683,6 +2693,11 @@ class StagedStore {
     __publicField(this, "adapter");
     __publicField(this, "hydrated");
     __publicField(this, "inFlight", /* @__PURE__ */ new Set());
+    // Per-key persistence chain — serializes save/remove for a key so they
+    // land in IndexedDB in call order (last write wins) instead of racing.
+    __publicField(this, "saveChains", /* @__PURE__ */ new Map());
+    // Listeners notified when a persistence op fails durably.
+    __publicField(this, "errorListeners", /* @__PURE__ */ new Set());
     this.adapter = adapter;
     this.hydrated = this.hydrate();
   }
@@ -2719,14 +2734,14 @@ class StagedStore {
       snapshot: next2.snapshot,
       buffered: next2.buffered
     };
-    this.track(this.adapter.save(key, persisted));
+    this.persist(key, () => this.adapter.save(key, persisted));
   }
   discard(workspace, path2) {
     const key = datasetCacheKey(workspace, path2);
     if (!this.entries.has(key)) return false;
     this.entries.delete(key);
     this.notify(key);
-    this.track(this.adapter.remove(key));
+    this.persist(key, () => this.adapter.remove(key));
     return true;
   }
   listKeys() {
@@ -2747,11 +2762,18 @@ class StagedStore {
   getKeyVersion(key) {
     return this.versions.get(key) ?? 0;
   }
+  onPersistError(cb) {
+    this.errorListeners.add(cb);
+    return () => {
+      this.errorListeners.delete(cb);
+    };
+  }
   /** Test-only: clear in-memory + persisted state. */
   async clear() {
     const keys = [...this.entries.keys()];
     this.entries.clear();
     for (const key of keys) this.notify(key);
+    await this.flushPending();
     await this.adapter.clear();
   }
   // ----- internals -------------------------------------------------------
@@ -2760,20 +2782,45 @@ class StagedStore {
     const subs = this.subscribers.get(key);
     if (subs) for (const cb of subs) cb();
   }
-  track(p2) {
-    const wrapped = p2.catch((err) => {
-      console.warn("[StagedStore] persistence operation failed:", err);
-    }).then(() => {
-      this.inFlight.delete(wrapped);
+  /**
+   * Serialize a persistence op behind any prior op for the same key, so they
+   * land in IndexedDB in call order (last write wins) rather than racing.
+   * Tracks the op for {@link flushPending} and routes failures to
+   * {@link onPersistError} listeners (falling back to a console warning).
+   */
+  persist(key, op) {
+    const prev2 = this.saveChains.get(key) ?? Promise.resolve();
+    const settled = prev2.then(op, op).then(
+      () => void 0,
+      (err) => {
+        this.emitPersistError(key, err);
+      }
+    ).then(() => {
+      if (this.saveChains.get(key) === settled) this.saveChains.delete(key);
+      this.inFlight.delete(settled);
     });
-    this.inFlight.add(wrapped);
+    this.saveChains.set(key, settled);
+    this.inFlight.add(settled);
+  }
+  emitPersistError(key, err) {
+    if (this.errorListeners.size === 0) {
+      console.warn("[StagedStore] persistence operation failed:", err);
+      return;
+    }
+    for (const cb of [...this.errorListeners]) {
+      try {
+        cb(key, err);
+      } catch (listenerErr) {
+        console.warn("[StagedStore] persist-error listener threw:", listenerErr);
+      }
+    }
   }
   async hydrate() {
     let persisted;
     try {
       persisted = await this.adapter.loadAll();
     } catch (err) {
-      console.warn("[StagedStore] hydrate failed:", err);
+      this.emitPersistError("", err);
       return;
     }
     for (const [key, p2] of persisted) {
@@ -2809,7 +2856,7 @@ function clearStagedStoreSingleton() {
 }
 const UNCHANGED_VARIANT = variant("unchanged", null);
 const blobEqual = equalFor(BlobType);
-const eastTypeEqual$1 = equalFor(EastTypeType);
+const eastTypeEqual$2 = equalFor(EastTypeType);
 const helpersCache = new SortedMap(
   void 0,
   compareFor(EastTypeType)
@@ -2862,6 +2909,7 @@ class BindRuntime {
     // List cache helpers.
     __publicField(this, "listCache", /* @__PURE__ */ new Map());
     this.staged = staged;
+    this.staged.onPersistError((_key, err) => this.emitWriteError(err));
   }
   // ----- cache singleton ------------------------------------------------
   /** Read the active cache. Throws if none has been initialized. */
@@ -2899,6 +2947,16 @@ class BindRuntime {
       this.writeErrorListeners.delete(cb);
     };
   }
+  /** Fan a write/persistence error out to every registered listener. */
+  emitWriteError(error3) {
+    for (const cb of this.writeErrorListeners) {
+      try {
+        cb(error3);
+      } catch (cbErr) {
+        console.error("Data.bind write-error listener threw:", cbErr);
+      }
+    }
+  }
   /** Resolve once every currently-queued write has finished
    *  (success or failure). Errors are NOT thrown — subscribe via
    *  {@link onWriteError} for those. */
@@ -2936,13 +2994,7 @@ class BindRuntime {
         await writeFn();
       } catch (error3) {
         console.error("Data.bind write failed:", error3);
-        for (const cb of this.writeErrorListeners) {
-          try {
-            cb(error3);
-          } catch (cbErr) {
-            console.error("Data.bind write-error listener threw:", cbErr);
-          }
-        }
+        this.emitWriteError(error3);
       }
     }
     this.isProcessingWrites = false;
@@ -2999,7 +3051,7 @@ class BindRuntime {
         return;
       }
       const shapeChanged = existing.mode !== info.mode || existing.hasPatchDataset !== info.hasPatchDataset;
-      const typeChanged = !eastTypeEqual$1(existing.sourceType, info.sourceType);
+      const typeChanged = !eastTypeEqual$2(existing.sourceType, info.sourceType);
       if (!shapeChanged && !typeChanged) {
         this.bindingRegistry.set(key, info);
         return;
@@ -3102,6 +3154,10 @@ class BindRuntime {
       }
       return null;
     };
+    const startLaunch = () => {
+      this.queueWrite(() => cache3.launchDataflow(ws));
+      return null;
+    };
     if (mode === "direct" && !patchPath) {
       return {
         read: () => {
@@ -3116,6 +3172,7 @@ class BindRuntime {
           this.queueWrite(() => cache3.writeAndStart(ws, sourcePath, encodeT(value)));
           return null;
         },
+        start: startLaunch,
         source: () => {
           this.trackPath(ws, sourcePath);
           return readSourceValue();
@@ -3149,6 +3206,7 @@ class BindRuntime {
           this.queueWrite(() => cache3.writeAndStart(ws, pPath2, encodePatch(next2)));
           return null;
         },
+        start: startLaunch,
         source: () => {
           this.trackPath(ws, sourcePath);
           return readSourceValue();
@@ -3162,12 +3220,8 @@ class BindRuntime {
           const patchVal = readPatchValue();
           this.queueWrite(async () => {
             const next2 = apply2(sourceVal, patchVal);
-            const writes = [];
-            cache3.batch(() => {
-              writes.push(cache3.write(ws, sourcePath, encodeT(next2)));
-              writes.push(cache3.write(ws, pPath2, encodePatch(UNCHANGED_VARIANT)));
-            });
-            await Promise.all(writes);
+            await cache3.write(ws, sourcePath, encodeT(next2));
+            await cache3.write(ws, pPath2, encodePatch(UNCHANGED_VARIANT));
           });
           return null;
         },
@@ -3193,6 +3247,7 @@ class BindRuntime {
         },
         write: writeStaged,
         writeAndStart: writeStaged,
+        start: startLaunch,
         source: () => {
           this.trackPath(ws, sourcePath);
           return readSourceValue();
@@ -3237,6 +3292,7 @@ class BindRuntime {
       },
       write: writeStaged,
       writeAndStart: writeStaged,
+      start: startLaunch,
       source: () => {
         this.trackPath(ws, sourcePath);
         return readSourceValue();
@@ -3385,6 +3441,110 @@ registerReactiveTracker({
   }
 });
 registerPlatformImplementation(BindPlatform);
+class TrackedChannelStore {
+  constructor() {
+    __publicField(this, "entries", /* @__PURE__ */ new Map());
+    // Per-key reactive subscription shim.
+    __publicField(this, "keySubscribers", /* @__PURE__ */ new Map());
+    __publicField(this, "keyVersions", /* @__PURE__ */ new Map());
+    // Reactive tracking — read closures push their channel keys here while a
+    // Reactive.Root render is being tracked.
+    __publicField(this, "trackingContext", null);
+  }
+  // ----- reactive tracking ----------------------------------------------
+  enableTracking() {
+    this.trackingContext = /* @__PURE__ */ new Set();
+    return this.trackingContext;
+  }
+  disableTracking() {
+    const keys = this.trackingContext ? [...this.trackingContext] : [];
+    this.trackingContext = null;
+    return keys;
+  }
+  isTracking() {
+    return this.trackingContext !== null;
+  }
+  /** Record a channel-key dependency for the current render (no-op when not
+   *  tracking). */
+  track(key) {
+    var _a2;
+    (_a2 = this.trackingContext) == null ? void 0 : _a2.add(key);
+  }
+  // ----- subscription shim ------------------------------------------------
+  subscribe(key, callback) {
+    let subs = this.keySubscribers.get(key);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.keySubscribers.set(key, subs);
+    }
+    subs.add(callback);
+    return () => {
+      subs.delete(callback);
+      if (subs.size === 0 && this.keySubscribers.get(key) === subs) {
+        this.keySubscribers.delete(key);
+      }
+    };
+  }
+  getKeyVersion(key) {
+    return this.keyVersions.get(key) ?? 0;
+  }
+  notify(key) {
+    this.keyVersions.set(key, (this.keyVersions.get(key) ?? 0) + 1);
+    const subs = this.keySubscribers.get(key);
+    if (subs) for (const cb of [...subs]) cb();
+  }
+  // ----- channel registry + latest-wins latch ----------------------------
+  entry(key) {
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = this.createEntry();
+      this.entries.set(key, entry);
+    }
+    return entry;
+  }
+  /**
+   * Open a latest-wins launch on a channel: bump the seq, mark the entry
+   * `running`, optionally `reset` it (e.g. clear a prior error), notify, and
+   * return a `settle` that applies a terminal mutation only if this launch is
+   * still the current one (a superseded / cancelled launch settles to a
+   * no-op).
+   */
+  beginLaunch(key, reset2) {
+    const entry = this.entry(key);
+    entry.launchSeq += 1;
+    const mySeq = entry.launchSeq;
+    entry.status = "running";
+    reset2 == null ? void 0 : reset2(entry);
+    this.notify(key);
+    const settle = (mutate) => {
+      const current = this.entries.get(key);
+      if (!current || current.launchSeq !== mySeq) return;
+      mutate(current);
+      this.notify(key);
+    };
+    return { entry, settle };
+  }
+  /**
+   * Client-side cancel: if the channel is running, orphan the in-flight wait
+   * (bump the seq) and mark it `cancelled`. `after` runs before the notify,
+   * for subclass-specific cleanup (e.g. dropping an in-flight handle).
+   */
+  cancelChannel(key, after) {
+    const entry = this.entries.get(key);
+    if (entry && entry.status === "running") {
+      entry.launchSeq += 1;
+      entry.status = "cancelled";
+      after == null ? void 0 : after(entry);
+      this.notify(key);
+    }
+  }
+  /** Drop all channel state (entries + subscriptions + versions). */
+  clearChannels() {
+    this.entries.clear();
+    this.keySubscribers.clear();
+    this.keyVersions.clear();
+  }
+}
 function createDefaultFunctionApi(apiUrl, repo, getToken) {
   const opts = () => ({ token: getToken() });
   return {
@@ -3400,8 +3560,8 @@ function createDefaultFunctionApi(apiUrl, repo, getToken) {
     }
   };
 }
-const eastTypeEqual = equalFor(EastTypeType);
-function signatureOfHandleType(handleType) {
+const eastTypeEqual$1 = equalFor(EastTypeType);
+function signatureOfFuncHandleType(handleType) {
   var _a2, _b2;
   if (handleType.type !== "Struct") {
     throw new Error(`Func.bind: handle type must be a Struct; got ${handleType.type}`);
@@ -3460,10 +3620,10 @@ function errorOfExecuteResult(result) {
         stderr: result.stderr
       };
     default:
-      return transportError(`unexpected outcome "${outcome.type}"`);
+      return transportError$1(`unexpected outcome "${outcome.type}"`);
   }
 }
-function transportError(message) {
+function transportError$1(message) {
   return {
     kind: variant("transport", { message }),
     message,
@@ -3474,20 +3634,16 @@ function transportError(message) {
 function funcChannelKey(workspace, name) {
   return `func:${workspace}:${name}`;
 }
-class FuncRuntime {
+class FuncRuntime extends TrackedChannelStore {
   constructor() {
+    super(...arguments);
     __publicField(this, "api", null);
     __publicField(this, "workspace", null);
-    __publicField(this, "entries", /* @__PURE__ */ new Map());
     // Signature lists are fetched once per workspace and cached.
     __publicField(this, "signatureLists", /* @__PURE__ */ new Map());
-    // Subscription shim — same contract (and the same stale-disposer
-    // guard) as the dataset cache's.
-    __publicField(this, "keySubscribers", /* @__PURE__ */ new Map());
-    __publicField(this, "keyVersions", /* @__PURE__ */ new Map());
-    // Reactive tracking — read closures push their channel keys here while
-    // a Reactive.Root render is being tracked.
-    __publicField(this, "trackingContext", null);
+  }
+  createEntry() {
+    return { status: "idle", launchSeq: 0 };
   }
   // ----- wiring ----------------------------------------------------------
   /** Install the API adapter + workspace — called by the React provider
@@ -3500,59 +3656,8 @@ class FuncRuntime {
   clear() {
     this.api = null;
     this.workspace = null;
-    this.entries.clear();
+    this.clearChannels();
     this.signatureLists.clear();
-    this.keySubscribers.clear();
-    this.keyVersions.clear();
-  }
-  // ----- reactive tracking ----------------------------------------------
-  enableTracking() {
-    this.trackingContext = /* @__PURE__ */ new Set();
-    return this.trackingContext;
-  }
-  disableTracking() {
-    const keys = this.trackingContext ? [...this.trackingContext] : [];
-    this.trackingContext = null;
-    return keys;
-  }
-  isTracking() {
-    return this.trackingContext !== null;
-  }
-  track(key) {
-    var _a2;
-    (_a2 = this.trackingContext) == null ? void 0 : _a2.add(key);
-  }
-  // ----- subscription shim ------------------------------------------------
-  subscribe(key, callback) {
-    let subs = this.keySubscribers.get(key);
-    if (!subs) {
-      subs = /* @__PURE__ */ new Set();
-      this.keySubscribers.set(key, subs);
-    }
-    subs.add(callback);
-    return () => {
-      subs.delete(callback);
-      if (subs.size === 0 && this.keySubscribers.get(key) === subs) {
-        this.keySubscribers.delete(key);
-      }
-    };
-  }
-  getKeyVersion(key) {
-    return this.keyVersions.get(key) ?? 0;
-  }
-  notify(key) {
-    this.keyVersions.set(key, (this.keyVersions.get(key) ?? 0) + 1);
-    const subs = this.keySubscribers.get(key);
-    if (subs) for (const cb of [...subs]) cb();
-  }
-  // ----- registry ----------------------------------------------------------
-  entry(key) {
-    let entry = this.entries.get(key);
-    if (!entry) {
-      entry = { status: "idle", launchSeq: 0 };
-      this.entries.set(key, entry);
-    }
-    return entry;
   }
   /** The deployed signature list for a workspace (fetched once). */
   signatures(workspace) {
@@ -3575,7 +3680,7 @@ class FuncRuntime {
     try {
       list = await this.signatures(workspace);
     } catch (err) {
-      return transportError(`failed to list workspace functions: ${err instanceof Error ? err.message : String(err)}`);
+      return transportError$1(`failed to list workspace functions: ${err instanceof Error ? err.message : String(err)}`);
     }
     const deployed = list.find((f2) => f2.name === name);
     if (!deployed) {
@@ -3586,8 +3691,8 @@ class FuncRuntime {
         stderr: ""
       };
     }
-    const inputsMatch = deployed.inputTypes.length === sig.inputs.length && deployed.inputTypes.every((t4, i) => eastTypeEqual(t4, sig.inputs[i]));
-    const outputMatches = eastTypeEqual(deployed.outputType, sig.output);
+    const inputsMatch = deployed.inputTypes.length === sig.inputs.length && deployed.inputTypes.every((t4, i) => eastTypeEqual$1(t4, sig.inputs[i]));
+    const outputMatches = eastTypeEqual$1(deployed.outputType, sig.output);
     if (!inputsMatch || !outputMatches) {
       const message = `signature mismatch for "${name}": bound (${sig.inputs.length} inputs) disagrees with the deployed package`;
       return {
@@ -3602,17 +3707,7 @@ class FuncRuntime {
   // ----- closure semantics -------------------------------------------------
   launch(workspace, name, sig, args) {
     const key = funcChannelKey(workspace, name);
-    const entry = this.entry(key);
-    entry.launchSeq += 1;
-    const mySeq = entry.launchSeq;
-    entry.status = "running";
-    this.notify(key);
-    const settle = (mutate) => {
-      const current = this.entries.get(key);
-      if (!current || current.launchSeq !== mySeq) return;
-      mutate(current);
-      this.notify(key);
-    };
+    const { settle } = this.beginLaunch(key);
     void (async () => {
       const invalid = await this.validate(workspace, name, sig);
       if (invalid) {
@@ -3626,7 +3721,7 @@ class FuncRuntime {
       if (!api3) {
         settle((e3) => {
           e3.status = "failed";
-          e3.error = transportError("no FunctionApi installed");
+          e3.error = transportError$1("no FunctionApi installed");
         });
         return;
       }
@@ -3637,7 +3732,7 @@ class FuncRuntime {
       } catch (err) {
         settle((e3) => {
           e3.status = "failed";
-          e3.error = transportError(err instanceof Error ? err.message : String(err));
+          e3.error = transportError$1(err instanceof Error ? err.message : String(err));
         });
         return;
       }
@@ -3648,7 +3743,7 @@ class FuncRuntime {
         } catch (err) {
           settle((e3) => {
             e3.status = "failed";
-            e3.error = transportError(`failed to decode result: ${err instanceof Error ? err.message : String(err)}`);
+            e3.error = transportError$1(`failed to decode result: ${err instanceof Error ? err.message : String(err)}`);
           });
           return;
         }
@@ -3668,7 +3763,7 @@ class FuncRuntime {
   }
   /** Build the handle value for one `Func.bind` platform evaluation. */
   buildHandle(handleType, name) {
-    const sig = signatureOfHandleType(handleType);
+    const sig = signatureOfFuncHandleType(handleType);
     const runtime = this;
     const resolveWorkspace = () => {
       if (!runtime.workspace) {
@@ -3706,12 +3801,8 @@ class FuncRuntime {
         return entry.status === "running";
       },
       cancel: () => {
-        const { key, entry } = channel();
-        if (entry.status === "running") {
-          entry.launchSeq += 1;
-          entry.status = "cancelled";
-          runtime.notify(key);
-        }
+        const { key } = channel();
+        runtime.cancelChannel(key);
         return null;
       },
       binding: { name }
@@ -7451,6 +7542,430 @@ var faCircleInfo = {
   iconName: "circle-info",
   icon: [512, 512, ["info-circle"], "f05a", "M256 512a256 256 0 1 0 0-512 256 256 0 1 0 0 512zM224 160a32 32 0 1 1 64 0 32 32 0 1 1 -64 0zm-8 64l48 0c13.3 0 24 10.7 24 24l0 88 8 0c13.3 0 24 10.7 24 24s-10.7 24-24 24l-80 0c-13.3 0-24-10.7-24-24s10.7-24 24-24l24 0 0-64-24 0c-13.3 0-24-10.7-24-24s10.7-24 24-24z"]
 };
+function createDefaultRecordApi(apiUrl, repo, getToken) {
+  const opts = () => ({ token: getToken() });
+  return {
+    async describe(workspace, record) {
+      return workspaceRecordDescribe(apiUrl, repo, workspace, record, opts());
+    },
+    async mutate(workspace, record, mutation, req) {
+      return workspaceRecordMutate(apiUrl, repo, workspace, record, mutation, {
+        args: req.args,
+        actor: none$1,
+        limits: none$1
+      }, opts());
+    },
+    async history(workspace, record, limit2, from2) {
+      return workspaceRecordHistory(apiUrl, repo, workspace, record, limit2, opts(), from2);
+    }
+  };
+}
+const eastTypeEqual = equalFor(EastTypeType);
+const RESERVED_MUTATE_FIELDS = /* @__PURE__ */ new Set(["pending", "status", "error", "cancel"]);
+function signatureOfRecordHandleType(handleType) {
+  var _a2, _b2;
+  if (handleType.type !== "Struct") {
+    throw new Error(`Record.bind: handle type must be a Struct; got ${handleType.type}`);
+  }
+  const fields = handleType.value;
+  const read = (_a2 = fields.find((f2) => f2.name === "read")) == null ? void 0 : _a2.type;
+  const mutate = (_b2 = fields.find((f2) => f2.name === "mutate")) == null ? void 0 : _b2.type;
+  if ((read == null ? void 0 : read.type) !== "Function") {
+    throw new Error("Record.bind: handle type is missing its read closure");
+  }
+  if ((mutate == null ? void 0 : mutate.type) !== "Struct") {
+    throw new Error("Record.bind: handle type is missing its mutate struct");
+  }
+  const stateType = read.value.output;
+  const mutations = /* @__PURE__ */ new Map();
+  for (const field of mutate.value) {
+    if (RESERVED_MUTATE_FIELDS.has(field.name)) continue;
+    if (field.type.type !== "Function") {
+      throw new Error(`Record.bind: mutate field "${field.name}" must be a closure`);
+    }
+    mutations.set(field.name, field.type.value.inputs);
+  }
+  return { stateType, mutations };
+}
+function errorOfMutationResult(result) {
+  const outcome = result.outcome;
+  switch (outcome.type) {
+    case "invalid":
+      return { kind: variant("invalid", { message: outcome.value.message }), message: outcome.value.message, stderr: "" };
+    case "failed":
+      return {
+        kind: variant("failed", { exitCode: outcome.value.exitCode }),
+        message: `reducer exited with code ${outcome.value.exitCode}`,
+        stderr: outcome.value.stderr
+      };
+    case "too_large":
+      return {
+        kind: 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: variant("timed_out", { ms: outcome.value.ms }),
+        message: `mutation timed out after ${outcome.value.ms}ms (server deadline)`,
+        stderr: outcome.value.stderr
+      };
+    case "conflict":
+      return {
+        kind: variant("conflict", { attempts: outcome.value.attempts }),
+        message: `compare-and-swap conflicted after ${outcome.value.attempts} attempts; try again`,
+        stderr: ""
+      };
+    default:
+      return transportError(`unexpected outcome "${outcome.type}"`);
+  }
+}
+function transportError(message) {
+  return { kind: variant("transport", { message }), message, stderr: "" };
+}
+function recordPath(name) {
+  return [variant("field", "records"), variant("field", name)];
+}
+function recordChannelKey(workspace, name) {
+  return `record:${workspace}:${name}`;
+}
+class RecordRuntime extends TrackedChannelStore {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "api", null);
+    __publicField(this, "cache", null);
+    __publicField(this, "workspace", null);
+    // Describe signatures, fetched once per (workspace, record), failures evicted.
+    __publicField(this, "signatureCache", /* @__PURE__ */ new Map());
+    // History per channel, fetched once + refreshed on commit.
+    __publicField(this, "histories", /* @__PURE__ */ new Map());
+    __publicField(this, "historyInFlight", /* @__PURE__ */ new Set());
+    // Channels whose last history fetch failed. Guards `history()` from
+    // re-issuing the request on every render (a failing endpoint would
+    // otherwise spin); cleared on the next commit / on clear() so a later
+    // mutation retries.
+    __publicField(this, "historyFailed", /* @__PURE__ */ new Set());
+  }
+  createEntry() {
+    return { status: "idle", launchSeq: 0 };
+  }
+  // ----- wiring ----------------------------------------------------------
+  /** Install the API adapter + dataset cache + workspace — called by the
+   *  React provider (or a test/showcase harness) before any handle is used. */
+  initialize(api3, cache3, workspace) {
+    this.api = api3;
+    this.cache = cache3;
+    this.workspace = workspace;
+  }
+  /** Tear down the adapter and all record state. */
+  clear() {
+    this.api = null;
+    this.cache = null;
+    this.workspace = null;
+    this.clearChannels();
+    this.signatureCache.clear();
+    this.histories.clear();
+    this.historyInFlight.clear();
+    this.historyFailed.clear();
+  }
+  resolveWorkspace() {
+    if (!this.workspace) {
+      throw new Error("Record.bind: no workspace configured — mount a provider (or call initializeRecordApi) first");
+    }
+    return this.workspace;
+  }
+  /** The deployed describe signature for a record (fetched once, evicted on failure). */
+  signature(workspace, record) {
+    const sigKey = `${workspace}:${record}`;
+    let promise4 = this.signatureCache.get(sigKey);
+    if (!promise4) {
+      const api3 = this.api;
+      if (!api3) return Promise.reject(new Error("Record.bind: no RecordApi installed"));
+      promise4 = api3.describe(workspace, record).catch((err) => {
+        this.signatureCache.delete(sigKey);
+        throw err;
+      });
+      this.signatureCache.set(sigKey, promise4);
+    }
+    return promise4;
+  }
+  /** Validate a mutation's declared arg types against the deployed signature. */
+  async validate(workspace, record, mutation, argTypes) {
+    let sig;
+    try {
+      sig = await this.signature(workspace, record);
+    } catch (err) {
+      return transportError(`failed to describe record "${record}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const deployed = sig.mutations.find((m2) => m2.name === mutation);
+    if (!deployed) {
+      const message = `no mutation "${mutation}" on record "${record}" in the deployed package`;
+      return { kind: variant("invalid", { message }), message, stderr: "" };
+    }
+    const argsMatch = deployed.argTypes.length === argTypes.length && deployed.argTypes.every((t4, i) => eastTypeEqual(t4, argTypes[i]));
+    if (!argsMatch) {
+      const message = `signature mismatch for mutation "${mutation}": bound (${argTypes.length} args) disagrees with the deployed package`;
+      return { kind: variant("invalid", { message }), message, stderr: "" };
+    }
+    return null;
+  }
+  /** Fetch a record's history once per channel (deduped); notify on settle. */
+  fetchHistory(workspace, record, key) {
+    if (this.historyInFlight.has(key)) return;
+    this.historyInFlight.add(key);
+    void (async () => {
+      const api3 = this.api;
+      try {
+        if (!api3) throw new Error("no RecordApi installed");
+        const result = await api3.history(workspace, record, void 0);
+        this.histories.set(key, result.commits);
+        this.historyFailed.delete(key);
+      } catch {
+        this.historyFailed.add(key);
+      } finally {
+        this.historyInFlight.delete(key);
+        this.notify(key);
+      }
+    })();
+  }
+  // ----- closure semantics -------------------------------------------------
+  launchMutation(workspace, record, mutation, argTypes, args) {
+    const key = recordChannelKey(workspace, record);
+    const { entry, settle } = this.beginLaunch(key, (e3) => {
+      delete e3.error;
+    });
+    const run = (async () => {
+      var _a2;
+      const invalid = await this.validate(workspace, record, mutation, argTypes);
+      if (invalid) {
+        settle((e3) => {
+          e3.status = "failed";
+          e3.error = invalid;
+        });
+        return;
+      }
+      const api3 = this.api;
+      if (!api3) {
+        settle((e3) => {
+          e3.status = "failed";
+          e3.error = transportError("no RecordApi installed");
+        });
+        return;
+      }
+      let result;
+      try {
+        const encoded = args.map((arg, i) => encodeBeast2For(argTypes[i])(arg));
+        result = await api3.mutate(workspace, record, mutation, { args: encoded });
+      } catch (err) {
+        settle((e3) => {
+          e3.status = "failed";
+          e3.error = transportError(err instanceof Error ? err.message : String(err));
+        });
+        return;
+      }
+      if (result.outcome.type === "committed") {
+        settle((e3) => {
+          e3.status = "committed";
+          delete e3.error;
+        });
+        void ((_a2 = this.cache) == null ? void 0 : _a2.refresh(workspace));
+        this.histories.delete(key);
+        this.historyFailed.delete(key);
+        this.notify(key);
+      } else {
+        settle((e3) => {
+          e3.status = "failed";
+          e3.error = errorOfMutationResult(result);
+        });
+      }
+    })();
+    entry.inflight = run;
+    void run.finally(() => {
+      const current = this.entries.get(key);
+      if (current && current.inflight === run) delete current.inflight;
+    });
+  }
+  /** Build the handle value for one `Record.bind` platform evaluation. */
+  buildHandle(handleType, name) {
+    const sig = signatureOfRecordHandleType(handleType);
+    const decodeState = decodeBeast2For(sig.stateType);
+    const runtime = this;
+    const path2 = recordPath(name);
+    const requireCache = () => {
+      if (!runtime.cache) {
+        throw new Error("Record.bind: no dataset cache configured — mount a provider first");
+      }
+      return runtime.cache;
+    };
+    const mutate = {
+      pending: () => {
+        const ws = runtime.resolveWorkspace();
+        const key = recordChannelKey(ws, name);
+        runtime.track(key);
+        return runtime.entry(key).status === "running";
+      },
+      status: () => {
+        const ws = runtime.resolveWorkspace();
+        const key = recordChannelKey(ws, name);
+        runtime.track(key);
+        return variant(runtime.entry(key).status, null);
+      },
+      error: () => {
+        const ws = runtime.resolveWorkspace();
+        const key = recordChannelKey(ws, name);
+        runtime.track(key);
+        const entry = runtime.entry(key);
+        return entry.status === "failed" && entry.error !== void 0 ? some(entry.error) : none$1;
+      },
+      cancel: () => {
+        const ws = runtime.resolveWorkspace();
+        runtime.cancelChannel(recordChannelKey(ws, name), (e3) => {
+          delete e3.error;
+          delete e3.inflight;
+        });
+        return null;
+      }
+    };
+    for (const [mutationName, argTypes] of sig.mutations) {
+      mutate[mutationName] = (...args) => {
+        runtime.launchMutation(runtime.resolveWorkspace(), name, mutationName, argTypes, args);
+        return null;
+      };
+    }
+    return {
+      read: () => {
+        const ws = runtime.resolveWorkspace();
+        trackDatasetPath(ws, path2);
+        const bytes = requireCache().read(ws, path2);
+        if (bytes === void 0) {
+          throw new Error(`Record.bind: record state not loaded: ${datasetCacheKey(ws, path2)} (it should be preloaded via the UI task manifest)`);
+        }
+        return decodeState(bytes);
+      },
+      status: () => {
+        const ws = runtime.resolveWorkspace();
+        trackDatasetPath(ws, path2);
+        return requireCache().getStatus(ws, path2);
+      },
+      history: () => {
+        const ws = runtime.resolveWorkspace();
+        const key = recordChannelKey(ws, name);
+        runtime.track(key);
+        const cached = runtime.histories.get(key);
+        if (cached === void 0) {
+          if (!runtime.historyFailed.has(key)) runtime.fetchHistory(ws, name, key);
+          return none$1;
+        }
+        return some(cached);
+      },
+      mutate,
+      start: () => {
+        const ws = runtime.resolveWorkspace();
+        const cache3 = requireCache();
+        const inflight = runtime.entry(recordChannelKey(ws, name)).inflight;
+        void Promise.resolve(inflight).catch(() => void 0).then(() => cache3.launchDataflow(ws)).catch(() => void 0);
+        return null;
+      },
+      binding: { name, mutations: [...sig.mutations.keys()] }
+    };
+  }
+  // ----- platform building -------------------------------------------------
+  /** Build a `Record.bind` PlatformFunction bound to this runtime. Pass
+   *  `allowed=null` for an unscoped impl; pass a Set of record names for
+   *  manifest scoping. */
+  buildPlatform(allowed) {
+    return recordBindPlatformFn.implement(
+      (handleType) => (nameArg) => {
+        const name = nameArg;
+        if (allowed && !allowed.has(name)) {
+          throw new Error(
+            `Record.bind: record "${name}" is not in this UI task's manifest — bind it in the task body so derivation records it`
+          );
+        }
+        return this.buildHandle(handleType, name);
+      }
+    );
+  }
+}
+const defaultRecordRuntime = new RecordRuntime();
+function initializeRecordApi(api3, cache3, workspace) {
+  defaultRecordRuntime.initialize(api3, cache3, workspace);
+}
+function clearRecordApi() {
+  defaultRecordRuntime.clear();
+}
+const RecordPlatform = [defaultRecordRuntime.buildPlatform(null)];
+function createScopedRecordPlatform(records) {
+  return [defaultRecordRuntime.buildPlatform(new Set(records))];
+}
+function createInMemoryRecordApi(cache3, workspace, defs2) {
+  const compiled = /* @__PURE__ */ new Map();
+  for (const def of defs2) {
+    const stateType = toEastTypeValue(def.stateType);
+    const mutations = /* @__PURE__ */ new Map();
+    for (const m2 of def.mutations) {
+      mutations.set(m2.name, { argTypes: m2.argTypes.map((t4) => toEastTypeValue(t4)), reduce: m2.reduce });
+    }
+    const genesis = {
+      hash: `${def.name}-0`.padEnd(64, "0"),
+      parent: none$1,
+      state: `${def.name}-state-0`.padEnd(64, "0"),
+      mutation: "$init",
+      actor: "memory",
+      at: /* @__PURE__ */ new Date(0)
+    };
+    compiled.set(def.name, { stateType, mutations, commits: [genesis], seq: 0 });
+    void cache3.write(workspace, recordPath(def.name), encodeBeast2For(stateType)(def.initial));
+  }
+  return {
+    async describe(_ws, record) {
+      const c2 = compiled.get(record);
+      if (!c2) throw new Error(`no in-memory record "${record}"`);
+      return {
+        name: record,
+        mutations: [...c2.mutations].map(([name, m2]) => ({ name, argTypes: m2.argTypes }))
+      };
+    },
+    async mutate(ws, record, mutation, req) {
+      const c2 = compiled.get(record);
+      if (!c2) throw new Error(`no in-memory record "${record}"`);
+      const m2 = c2.mutations.get(mutation);
+      if (!m2) return { outcome: variant("invalid", { message: `no mutation "${mutation}"` }) };
+      const current = cache3.read(ws, recordPath(record));
+      const state = current !== void 0 ? decodeBeast2For(c2.stateType)(current) : void 0;
+      const args = req.args.map((bytes, i) => decodeBeast2For(m2.argTypes[i])(bytes));
+      const next2 = m2.reduce(state, ...args);
+      await cache3.write(ws, recordPath(record), encodeBeast2For(c2.stateType)(next2));
+      c2.seq += 1;
+      const hash2 = `${record}-${c2.seq}`.padEnd(64, "0");
+      c2.commits.unshift({
+        hash: hash2,
+        parent: some(c2.commits[0].hash),
+        state: `${record}-state-${c2.seq}`.padEnd(64, "0"),
+        mutation,
+        actor: "memory",
+        at: /* @__PURE__ */ new Date(0)
+      });
+      return { outcome: variant("committed", { commitHash: hash2, stateHash: `${record}-state-${c2.seq}`.padEnd(64, "0") }) };
+    },
+    async history(_ws, record, limit2) {
+      const c2 = compiled.get(record);
+      if (!c2) throw new Error(`no in-memory record "${record}"`);
+      const commits = limit2 !== void 0 ? c2.commits.slice(0, limit2) : c2.commits;
+      return { commits };
+    }
+  };
+}
+registerReactiveTracker({
+  id: "record-bind",
+  enableTracking: () => defaultRecordRuntime.enableTracking(),
+  disableTracking: () => defaultRecordRuntime.disableTracking(),
+  getStore: () => ({
+    subscribe: (key, cb) => defaultRecordRuntime.subscribe(key, cb),
+    getKeyVersion: (key) => defaultRecordRuntime.getKeyVersion(key)
+  })
+});
+registerPlatformImplementation(RecordPlatform);
 const E3ConfigContext = createContext(null);
 function E3Provider({ children: children2, config: config2, queryClient: externalClient }) {
   const client = useMemo(
@@ -7501,11 +8016,21 @@ function ReactiveDatasetProvider({
       );
     }
   }, [e3.apiUrl, e3.repo, e3.workspace]);
+  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]);
   useEffect(() => {
     return () => {
       const ws = cache3.getConfig().workspace;
       clearReactiveDatasetCache();
       clearFunctionApi();
+      clearRecordApi();
       cache3.destroy();
       if (ws) clearBindingRegistry(ws);
       else clearBindingRegistry();
@@ -60713,30 +61238,37 @@ function RefusalZone({ refusal, overlap, naiveValue, outcome }) {
   ] });
 }
 function ValidatePanel({ vm, barList }) {
-  const treatedPct = Math.round(vm.primary.treatedShare * 100);
+  const stat = useSlotRecipe({ key: "stat" })({ size: "lg" });
+  const meter = useSlotRecipe({ key: "segmentedMeter" })({});
   return /* @__PURE__ */ jsxs(Box, { p: "4.5", children: [
     /* @__PURE__ */ jsx$1(Cap, { help: "tab_validate", children: vm.headline }),
     /* @__PURE__ */ jsxs(Box, { display: "flex", alignItems: "flex-end", gap: "5", flexWrap: "wrap", children: [
-      /* @__PURE__ */ jsxs(Box, { display: "flex", flexDirection: "column", gap: "0.5", children: [
-        /* @__PURE__ */ jsx$1(Text, { textStyle: "mono.sm", color: "fg.muted", children: /* @__PURE__ */ jsx$1(Help, { id: "validate_size", children: vm.holdback ? "to hold back from" : "to run" }) }),
-        vm.faint ? /* @__PURE__ */ jsx$1(Text, { textStyle: "body.sm", fontWeight: "semibold", color: "fg.warning", maxW: "220px", children: "Effect too faint to size — set a materiality threshold to size a trial." }) : /* @__PURE__ */ jsx$1(Text, { textStyle: "mono-kpi", fontFamily: "heading", fontSize: "32px", color: "brand.solid", children: vm.primary.nTotal.toLocaleString() })
+      /* @__PURE__ */ jsxs(Box, { css: stat.root, children: [
+        /* @__PURE__ */ jsx$1(Text, { css: stat.label, children: /* @__PURE__ */ jsx$1(Help, { id: "validate_size", children: vm.holdback ? "to hold back from" : "to run" }) }),
+        vm.faint ? /* @__PURE__ */ jsx$1(Text, { textStyle: "body.sm", fontWeight: "semibold", color: "fg.warning", maxW: "220px", children: "Effect too faint to size — set a materiality threshold to size a trial." }) : /* @__PURE__ */ jsx$1(Text, { css: stat.valueText, color: "brand.solid", children: vm.primary.nTotal.toLocaleString() })
       ] }),
-      /* @__PURE__ */ jsxs(Box, { flex: "1", minW: "220px", children: [
-        /* @__PURE__ */ jsx$1(Cap, { help: "validate_split", children: vm.holdback ? "Hold-back split" : "Split" }),
-        /* @__PURE__ */ jsxs(Box, { display: "flex", h: "10px", borderRadius: "full", overflow: "hidden", borderWidth: "1px", borderColor: "border.subtle", children: [
-          /* @__PURE__ */ jsx$1(Box, { bg: "brand.solid", width: `${treatedPct}%` }),
-          /* @__PURE__ */ jsx$1(Box, { bg: "bg.emphasized", flex: "1" })
+      /* @__PURE__ */ jsxs(Box, { css: meter.root, flex: "1", minW: "220px", children: [
+        /* @__PURE__ */ jsx$1(Text, { css: meter.label, children: /* @__PURE__ */ jsx$1(Help, { id: "validate_split", children: vm.holdback ? "Hold-back split" : "Split" }) }),
+        /* @__PURE__ */ jsxs(Box, { css: meter.track, children: [
+          /* @__PURE__ */ jsx$1(Box, { css: meter.segment, flex: vm.primary.treatedShare, bg: "brand.solid" }),
+          /* @__PURE__ */ jsx$1(Box, { css: meter.segment, flex: 1 - vm.primary.treatedShare, bg: "bg.emphasized" })
         ] }),
-        /* @__PURE__ */ jsxs(Box, { display: "flex", justifyContent: "space-between", mt: "1.5", children: [
-          /* @__PURE__ */ jsxs(Text, { textStyle: "caption", children: [
-            /* @__PURE__ */ jsx$1(Text, { as: "span", color: "brand.fg", fontWeight: "semibold", children: vm.primary.nTreated.toLocaleString() }),
-            " ",
-            vm.holdback ? "treated" : "get it"
+        /* @__PURE__ */ jsxs(Box, { css: meter.keyRow, justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs(Box, { css: meter.keyItem, children: [
+            /* @__PURE__ */ jsx$1(Box, { css: meter.keyDot, bg: "brand.solid" }),
+            /* @__PURE__ */ jsxs("span", { children: [
+              /* @__PURE__ */ jsx$1(Text, { as: "span", css: meter.valueText, children: vm.primary.nTreated.toLocaleString() }),
+              " ",
+              vm.holdback ? "treated" : "get it"
+            ] })
           ] }),
-          /* @__PURE__ */ jsxs(Text, { textStyle: "caption", children: [
-            /* @__PURE__ */ jsx$1(Text, { as: "span", color: "fg.default", fontWeight: "semibold", children: vm.primary.nControl.toLocaleString() }),
-            " ",
-            vm.holdback ? "held back" : "left alone"
+          /* @__PURE__ */ jsxs(Box, { css: meter.keyItem, children: [
+            /* @__PURE__ */ jsx$1(Box, { css: meter.keyDot, bg: "bg.emphasized" }),
+            /* @__PURE__ */ jsxs("span", { children: [
+              /* @__PURE__ */ jsx$1(Text, { as: "span", css: meter.valueText, children: vm.primary.nControl.toLocaleString() }),
+              " ",
+              vm.holdback ? "held back" : "left alone"
+            ] })
           ] })
         ] })
       ] })
@@ -63028,7 +63560,7 @@ const UITaskPreview = memo(function UITaskPreview2({
   const manifest = useMemo(() => {
     if (!details || !isUI) return null;
     const meta3 = getTaskMetadata(details);
-    return meta3 ? decodeManifest(meta3) : { paths: [], functions: [] };
+    return meta3 ? decodeManifest(meta3) : { paths: [], functions: [], records: [] };
   }, [details, isUI]);
   const outputPath = details ? treePathToString$1(details.output) : null;
   const preloads = useMemo(
@@ -63041,6 +63573,7 @@ const UITaskPreview = memo(function UITaskPreview2({
       ...StateImpl,
       ...createScopedBindPlatform(manifest),
       ...createScopedFuncPlatform(manifest.functions),
+      ...createScopedRecordPlatform(manifest.records),
       ...OverlayImpl
     ] : void 0,
     [manifest]
@@ -63639,6 +64172,8 @@ export {
   ReactiveDatasetCache,
   ReactiveDatasetLoader,
   ReactiveDatasetProvider,
+  RecordPlatform,
+  RecordRuntime,
   StagedStore,
   StatusDisplay,
   TaskPreview,
@@ -63650,17 +64185,22 @@ export {
   clearPendingWrites,
   clearReactiveDatasetCache,
   clearReactiveDatasetListCache,
+  clearRecordApi,
   clearStagedStoreSingleton,
   createDefaultDatasetApi,
   createDefaultFunctionApi,
+  createDefaultRecordApi,
   createInMemoryFunctionApi,
+  createInMemoryRecordApi,
   createReactiveDatasetCache,
   createScopedBindPlatform,
   createScopedFuncPlatform,
+  createScopedRecordPlatform,
   datasetCacheKey,
   datasetPathToString,
   defaultBindRuntime,
   defaultFuncRuntime,
+  defaultRecordRuntime,
   disableBindingTracking,
   enableBindingTracking,
   formatApiError,
@@ -63673,12 +64213,14 @@ export {
   getTaskMetadata,
   initializeFunctionApi,
   initializeReactiveDatasetCache,
+  initializeRecordApi,
   initializeStagedStore,
   isBindingTracking,
   onWriteError,
   preloadReactiveDatasetList,
   realClock,
-  signatureOfHandleType,
+  recordChannelKey,
+  signatureOfFuncHandleType,
   trackDatasetPath,
   useDataflowCancel,
   useDataflowExecute,