@elaraai/e3-ui-components 1.0.26 → 1.0.27

package/dist/index.js

@@ -18,16 +18,17 @@ 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, none as none$1, some, walkPatch, pathToString, pathDisplay, printFor, isVariant, prunePatchFor, detectConflictsFor, mergeWithResolutionsFor, validatePatchFor, fromEastTypeValue, OptionType, StringType } 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, StructType, StringType, walkPatch, pathToString, pathDisplay, printFor, isVariant, prunePatchFor, detectConflictsFor, mergeWithResolutionsFor, validatePatchFor, ArrayType } from "@elaraai/east";
 import { EastTypeType } from "@elaraai/east/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 { 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 { registerReactiveTracker, registerPlatformImplementation, getSomeorUndefined as getSomeorUndefined$1, StateRuntime, buildSliceHandle, DEFAULT_SLICE_STATE, getRegisteredPlatformImplementations } 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 } 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";
 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, Badge, Button, Tabs, useTabs } from "@chakra-ui/react";
-import { implementUIComponent, getSomeorUndefined, formatPredicate, SliceEditPopover, SlicePredicateBuilder, StateRuntime, buildSliceHandle, DEFAULT_SLICE_STATE, registerPlatformImplementation as registerPlatformImplementation$1, EastChakraSelect, EastChakraStringInput, EastChakraDateTimeInput, EastChakraFloatInput, EastChakraIntegerInput, formatTick, useSliceReactivity, SliceRailCluster, EastChakraComponent, ClauseChip, StateImpl, NavImpl, SliceImpl, SliceApplyImpl, OverlayImpl, ClipboardImpl, DownloadImpl, ShareImpl, createUIStore, UIStoreProvider } from "@elaraai/east-ui-components";
+import { implementUIComponent, getSomeorUndefined, formatPredicate, SliceEditPopover, SlicePredicateBuilder, EastChakraSelect, EastChakraStringInput, EastChakraDateTimeInput, EastChakraFloatInput, EastChakraIntegerInput, formatTick, useSliceReactivity, SliceRailCluster, EastChakraComponent, ClauseChip, StateImpl, NavImpl, SliceImpl, SliceApplyImpl, OverlayImpl, ClipboardImpl, DownloadImpl, ShareImpl, createUIStore, UIStoreProvider } 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 } from "@tanstack/react-query";
@@ -2916,6 +2917,17 @@ class BindRuntime {
     __publicField(this, "fallbackWarningEmitted", /* @__PURE__ */ new Set());
     // List cache helpers.
     __publicField(this, "listCache", /* @__PURE__ */ new Map());
+    // Compiled-handle cache (issue #106 perf). The bind impl compiles N
+    // East.function methods per bind, and binds re-run on every reactive frame.
+    // The compiled IR is a pure function of (sourceType, sourcePath, patch, mode)
+    // — same key ⇒ same methods — and the methods resolve cache/workspace LIVE,
+    // so a cached handle still re-binds correctly across renders / cache swaps.
+    // Keyed *structurally* (each bind builds a fresh EastTypeValue from IR, so a
+    // by-identity cache would miss every render — same reason as helpersCache).
+    __publicField(this, "handleCache", new SortedMap(
+      void 0,
+      compareFor(EastTypeType)
+    ));
     this.staged = staged;
     this.staged.onPersistError((_key, err) => this.emitWriteError(err));
   }
@@ -2946,6 +2958,7 @@ class BindRuntime {
   clearCache() {
     this.cache = null;
     this.clearPendingWrites();
+    this.handleCache.clear();
   }
   // ----- pending writes queue -------------------------------------------
   /** Subscribe to write-queue errors. Returns an unsubscribe fn. */
@@ -3072,13 +3085,14 @@ class BindRuntime {
   }
   // ----- bind-handle construction --------------------------------------
   /**
-   * Build a bind handle for a single `(sourcePath, mode, patch?)`
-   * triple. Public so tests can call this directly without going
-   * through East's compile/dispatch pipeline.
+   * Build a `Data.bind` handle. Its methods are thin IR-bearing
+   * `East.function`s over the `data_*` primitives, capturing only the
+   * plain-data `{source, patch, mode}` descriptor — so the handle is ordinary
+   * serializable East data (issue #106) and re-binds to the decoder's cache.
+   * Public so tests can call it directly without East's compile/dispatch.
    *
-   * @throws `EastError` if the cache is uninitialized, the
-   *  workspace is not configured, or `allowed` is non-null and any
-   *  referenced path is not in it.
+   * @throws `EastError` if the cache is uninitialized, the workspace is not
+   *  configured, or `allowed` is non-null and any referenced path is not in it.
    */
   buildBindHandle(sourceType, sourcePath, patchPath, mode, allowed) {
     const cache3 = this.requireCache();
@@ -3102,6 +3116,106 @@ class BindRuntime {
         }
       }
     }
+    const { patchType } = getBindingHelpers(sourceType);
+    this.registerBindingTypes(ws, sourcePath, {
+      workspace: ws,
+      sourceType,
+      patchType,
+      mode,
+      hasPatchDataset: patchPath !== void 0
+    });
+    const descKey = `${datasetPathToString(sourcePath)}\0${patchPath !== void 0 ? datasetPathToString(patchPath) : ""}\0${mode}`;
+    let byDesc = this.handleCache.get(sourceType);
+    if (byDesc) {
+      const hit = byDesc.get(descKey);
+      if (hit) return hit;
+    } else {
+      byDesc = /* @__PURE__ */ new Map();
+      this.handleCache.set(sourceType, byDesc);
+    }
+    const T2 = fromEastTypeValue(sourceType);
+    const srcExpr = East.value(sourcePath, TreePathType);
+    const patchExpr = East.value(patchPath !== void 0 ? some(patchPath) : none$1, OptionType(TreePathType));
+    const modeExpr = East.value(variant(mode, null), DataBindModeType);
+    const platform = this.buildPrimitives();
+    const P2 = DataBindPrimitives;
+    const handle = {
+      read: East.compile(East.function([], T2, ($3) => {
+        $3.return(P2.read([T2], srcExpr, patchExpr, modeExpr));
+      }), platform),
+      write: East.compile(East.function([T2], NullType, ($3, v3) => {
+        $3.return(P2.write([T2], srcExpr, patchExpr, modeExpr, v3));
+      }), platform),
+      writeAndStart: East.compile(East.function([T2], NullType, ($3, v3) => {
+        $3.return(P2.writeAndStart([T2], srcExpr, patchExpr, modeExpr, v3));
+      }), platform),
+      start: East.compile(East.function([], NullType, ($3) => {
+        $3.return(P2.start([T2], srcExpr, patchExpr, modeExpr));
+      }), platform),
+      source: East.compile(East.function([], T2, ($3) => {
+        $3.return(P2.source([T2], srcExpr, patchExpr, modeExpr));
+      }), platform),
+      pending: East.compile(East.function([], BooleanType, ($3) => {
+        $3.return(P2.pending([T2], srcExpr, patchExpr, modeExpr));
+      }), platform),
+      commit: East.compile(East.function([], NullType, ($3) => {
+        $3.return(P2.commit([T2], srcExpr, patchExpr, modeExpr));
+      }), platform),
+      discard: East.compile(East.function([], NullType, ($3) => {
+        $3.return(P2.discard([T2], srcExpr, patchExpr, modeExpr));
+      }), platform),
+      has: East.compile(East.function([], BooleanType, ($3) => {
+        $3.return(P2.has([T2], srcExpr, patchExpr, modeExpr));
+      }), platform),
+      status: East.compile(East.function([], DatasetStatusType, ($3) => {
+        $3.return(P2.status([T2], srcExpr, patchExpr, modeExpr));
+      }), platform),
+      binding: {
+        source: sourcePath,
+        patch: patchPath !== void 0 ? some(patchPath) : none$1,
+        mode: variant(mode, null)
+      }
+    };
+    byDesc.set(descKey, handle);
+    return handle;
+  }
+  /**
+   * 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 here. Each impl
+   * recovers the `{source, patch, mode}` descriptor from its args and delegates
+   * to {@link buildRawHandle}, reusing the full mode×patch logic verbatim.
+   */
+  buildPrimitives() {
+    const raw = (sourceType, sourceArg, patchOpt, modeVariant) => {
+      const { patchPath, mode } = resolveOptions(patchOpt, modeVariant);
+      return this.buildRawHandle(sourceType, sourceArg, patchPath, mode);
+    };
+    const P2 = DataBindPrimitives;
+    return [
+      P2.read.implement((t4) => (s2, p2, m2) => raw(t4, s2, p2, m2).read()),
+      P2.source.implement((t4) => (s2, p2, m2) => raw(t4, s2, p2, m2).source()),
+      P2.write.implement((t4) => (s2, p2, m2, v3) => raw(t4, s2, p2, m2).write(v3)),
+      P2.writeAndStart.implement((t4) => (s2, p2, m2, v3) => raw(t4, s2, p2, m2).writeAndStart(v3)),
+      P2.start.implement((t4) => (s2, p2, m2) => raw(t4, s2, p2, m2).start()),
+      P2.pending.implement((t4) => (s2, p2, m2) => raw(t4, s2, p2, m2).pending()),
+      P2.commit.implement((t4) => (s2, p2, m2) => raw(t4, s2, p2, m2).commit()),
+      P2.discard.implement((t4) => (s2, p2, m2) => raw(t4, s2, p2, m2).discard()),
+      P2.has.implement((t4) => (s2, p2, m2) => raw(t4, s2, p2, m2).has()),
+      P2.status.implement((t4) => (s2, p2, m2) => raw(t4, s2, p2, m2).status())
+    ];
+  }
+  /**
+   * Build the raw (host-closure) bind handle for a single
+   * `(sourcePath, mode, patch?)` triple. The mode×patch matrix lives here; the
+   * serializable {@link buildBindHandle} wraps each method as an `East.function`
+   * over a primitive that delegates back here. Re-registers binding types on
+   * every call (decode self-heal). Public so tests can drive the raw closures.
+   */
+  buildRawHandle(sourceType, sourcePath, patchPath, mode) {
+    const cache3 = this.requireCache();
+    const ws = cache3.getConfig().workspace;
+    if (!ws) throw new Error("ReactiveDatasetCache workspace not configured");
     const { patchType, decodeT, encodeT, decodePatch, encodePatch, apply: apply2, diff: diff2 } = getBindingHelpers(sourceType);
     this.registerBindingTypes(ws, sourcePath, {
       workspace: ws,
@@ -3416,10 +3530,16 @@ function awaitPendingWrites() {
 function clearPendingWrites() {
   defaultBindRuntime.clearPendingWrites();
 }
-const BindPlatform = [defaultBindRuntime.buildPlatform(null)];
+const BindPlatform = [
+  defaultBindRuntime.buildPlatform(null),
+  ...defaultBindRuntime.buildPrimitives()
+];
 function createScopedBindPlatform(manifest) {
   const allowed = new Set(manifest.paths.map((p2) => datasetPathToString(p2)));
-  return [defaultBindRuntime.buildPlatform(allowed)];
+  return [
+    defaultBindRuntime.buildPlatform(allowed),
+    ...defaultBindRuntime.buildPrimitives()
+  ];
 }
 async function preloadReactiveDatasetList(workspace, path2) {
   return defaultBindRuntime.preloadList(workspace, path2);
@@ -3649,6 +3769,11 @@ class FuncRuntime extends TrackedChannelStore {
     __publicField(this, "workspace", null);
     // Signature lists are fetched once per workspace and cached.
     __publicField(this, "signatureLists", /* @__PURE__ */ new Map());
+    // Compiled-handle cache (issue #106 perf): buildHandle compiles 6 East.functions
+    // per bind, and binds re-run every reactive frame. The method IR is a pure
+    // function of the function name (which fixes the handle type), and the methods
+    // resolve workspace/api LIVE, so a cached handle still re-binds. Cleared on clear().
+    __publicField(this, "handleCache", /* @__PURE__ */ new Map());
   }
   createEntry() {
     return { status: "idle", launchSeq: 0 };
@@ -3666,6 +3791,7 @@ class FuncRuntime extends TrackedChannelStore {
     this.workspace = null;
     this.clearChannels();
     this.signatureLists.clear();
+    this.handleCache.clear();
   }
   /** The deployed signature list for a workspace (fetched once). */
   signatures(workspace) {
@@ -3769,9 +3895,15 @@ class FuncRuntime extends TrackedChannelStore {
       }
     })();
   }
-  /** Build the handle value for one `Func.bind` platform evaluation. */
-  buildHandle(handleType, name) {
-    const sig = signatureOfFuncHandleType(handleType);
+  /**
+   * The 6 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. The host effects (launch /
+   * channel reads + reactive tracking) live here, keyed only on the plain-data
+   * function name; the output type rides as a type-arg.
+   */
+  buildPrimitives() {
     const runtime = this;
     const resolveWorkspace = () => {
       if (!runtime.workspace) {
@@ -3779,42 +3911,91 @@ class FuncRuntime extends TrackedChannelStore {
       }
       return runtime.workspace;
     };
-    const channel = () => {
+    const channel = (name) => {
       const key = funcChannelKey(resolveWorkspace(), name);
       return { key, entry: runtime.entry(key) };
     };
-    return {
-      call: (...args) => {
-        runtime.launch(resolveWorkspace(), name, sig, args);
+    return [
+      // call: recover per-arg input types from the ArgsStruct type-arg + the
+      // values from the passed struct (field order), and the output type from O.
+      FuncBindPrimitives.call.implement((argsStructType, outputType) => (nameArg, argsStruct) => {
+        const fields = argsStructType.value;
+        const obj = argsStruct;
+        const inputs = fields.map((f2) => f2.type);
+        const args = fields.map((f2) => obj[f2.name]);
+        runtime.launch(resolveWorkspace(), nameArg, { inputs, output: outputType }, args);
         return null;
-      },
-      read: () => {
-        const { key, entry } = channel();
+      }),
+      FuncBindPrimitives.read.implement((_outputType) => (nameArg) => {
+        const { key, entry } = channel(nameArg);
         runtime.track(key);
         return entry.result !== void 0 ? variant("some", entry.result) : variant("none", null);
-      },
-      status: () => {
-        const { key, entry } = channel();
+      }),
+      FuncBindPrimitives.status.implement((nameArg) => {
+        const { key, entry } = channel(nameArg);
         runtime.track(key);
         return variant(entry.status, null);
-      },
-      error: () => {
-        const { key, entry } = channel();
+      }),
+      FuncBindPrimitives.error.implement((nameArg) => {
+        const { key, entry } = channel(nameArg);
         runtime.track(key);
         return entry.status === "failed" && entry.error !== void 0 ? variant("some", entry.error) : variant("none", null);
-      },
-      pending: () => {
-        const { key, entry } = channel();
+      }),
+      FuncBindPrimitives.pending.implement((nameArg) => {
+        const { key, entry } = channel(nameArg);
         runtime.track(key);
         return entry.status === "running";
-      },
-      cancel: () => {
-        const { key } = channel();
+      }),
+      FuncBindPrimitives.cancel.implement((nameArg) => {
+        const { key } = channel(nameArg);
         runtime.cancelChannel(key);
         return null;
-      },
+      })
+    ];
+  }
+  /**
+   * Build the handle value for one `Func.bind` evaluation. The methods are
+   * thin IR-bearing `East.function`s over {@link buildPrimitives}, capturing
+   * only the function name (and the signature types via type-args) — so the
+   * handle is ordinary serializable East data (issue #106).
+   */
+  buildHandle(handleType, name) {
+    const cached = this.handleCache.get(name);
+    if (cached) return cached;
+    const sig = signatureOfFuncHandleType(handleType);
+    const inputsEast = sig.inputs.map((t4) => fromEastTypeValue(t4));
+    const outputEast = fromEastTypeValue(sig.output);
+    const ArgsStruct = StructType(Object.fromEntries(inputsEast.map((t4, i) => [`arg${i}`, t4])));
+    const nameExpr = East.value(name, StringType);
+    const platform = this.buildPrimitives();
+    const { call, read, status, error: error3, pending, cancel } = FuncBindPrimitives;
+    const handle = {
+      call: East.compile(East.function(inputsEast, NullType, ($3, ...args) => {
+        const obj = {};
+        args.forEach((a2, i) => {
+          obj[`arg${i}`] = a2;
+        });
+        $3.return(call([ArgsStruct, outputEast], nameExpr, East.value(obj, ArgsStruct)));
+      }), platform),
+      read: East.compile(East.function([], OptionType(outputEast), ($3) => {
+        $3.return(read([outputEast], nameExpr));
+      }), platform),
+      status: East.compile(East.function([], FuncStatusType, ($3) => {
+        $3.return(status(nameExpr));
+      }), platform),
+      error: East.compile(East.function([], OptionType(FuncErrorType), ($3) => {
+        $3.return(error3(nameExpr));
+      }), platform),
+      pending: East.compile(East.function([], BooleanType, ($3) => {
+        $3.return(pending(nameExpr));
+      }), platform),
+      cancel: East.compile(East.function([], NullType, ($3) => {
+        $3.return(cancel(nameExpr));
+      }), platform),
       binding: { name }
     };
+    this.handleCache.set(name, handle);
+    return handle;
   }
   // ----- platform building -------------------------------------------------
   /** Build a `Func.bind` PlatformFunction bound to this runtime. Pass
@@ -3841,9 +4022,15 @@ function initializeFunctionApi(api3, workspace) {
 function clearFunctionApi() {
   defaultFuncRuntime.clear();
 }
-const FuncPlatform = [defaultFuncRuntime.buildPlatform(null)];
+const FuncPlatform = [
+  defaultFuncRuntime.buildPlatform(null),
+  ...defaultFuncRuntime.buildPrimitives()
+];
 function createScopedFuncPlatform(functions2) {
-  return [defaultFuncRuntime.buildPlatform(new Set(functions2))];
+  return [
+    defaultFuncRuntime.buildPlatform(new Set(functions2)),
+    ...defaultFuncRuntime.buildPrimitives()
+  ];
 }
 function createInMemoryFunctionApi(functions2) {
   const defs2 = functions2.map((def) => ({
@@ -7653,6 +7840,12 @@ class RecordRuntime extends TrackedChannelStore {
     // otherwise spin); cleared on the next commit / on clear() so a later
     // mutation retries.
     __publicField(this, "historyFailed", /* @__PURE__ */ new Set());
+    // Compiled-handle cache (issue #106 perf): buildHandle compiles 8 + (one per
+    // mutation) East.functions per bind, and binds re-run every reactive frame.
+    // The method IR is a pure function of the record name (which fixes the handle
+    // type), and the methods resolve cache/api/ws LIVE, so a cached handle still
+    // re-binds. Cleared on clear().
+    __publicField(this, "handleCache", /* @__PURE__ */ new Map());
   }
   createEntry() {
     return { status: "idle", launchSeq: 0 };
@@ -7675,6 +7868,7 @@ class RecordRuntime extends TrackedChannelStore {
     this.histories.clear();
     this.historyInFlight.clear();
     this.historyFailed.clear();
+    this.handleCache.clear();
   }
   resolveWorkspace() {
     if (!this.workspace) {
@@ -7793,89 +7987,163 @@ class RecordRuntime extends TrackedChannelStore {
       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);
+  /**
+   * 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 here. The host
+   * effects (dataset-cache reads + reactive tracking + mutation launch) live
+   * here, keyed only on the plain-data record name; the state type rides as a
+   * type-arg on `record_read`, and per-mutation arg types come from the
+   * `record_mutate` ArgsStruct type-arg.
+   */
+  buildPrimitives() {
     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: () => {
+    return [
+      RecordBindPrimitives.read.implement((stateType) => {
+        const decode = decodeBeast2For(stateType);
+        return (nameArg) => {
+          const ws = runtime.resolveWorkspace();
+          const path2 = recordPath(nameArg);
+          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 decode(bytes);
+        };
+      }),
+      RecordBindPrimitives.status.implement((nameArg) => {
+        const ws = runtime.resolveWorkspace();
+        const path2 = recordPath(nameArg);
+        trackDatasetPath(ws, path2);
+        return requireCache().getStatus(ws, path2);
+      }),
+      RecordBindPrimitives.history.implement((nameArg) => {
+        const name = nameArg;
         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);
+      }),
+      RecordBindPrimitives.start.implement((nameArg) => {
+        const ws = runtime.resolveWorkspace();
+        const cache3 = requireCache();
+        const inflight = runtime.entry(recordChannelKey(ws, nameArg)).inflight;
+        void Promise.resolve(inflight).catch(() => void 0).then(() => cache3.launchDataflow(ws)).catch(() => void 0);
+        return null;
+      }),
+      RecordBindPrimitives.mutatePending.implement((nameArg) => {
+        const ws = runtime.resolveWorkspace();
+        const key = recordChannelKey(ws, nameArg);
+        runtime.track(key);
         return runtime.entry(key).status === "running";
-      },
-      status: () => {
+      }),
+      RecordBindPrimitives.mutateStatus.implement((nameArg) => {
         const ws = runtime.resolveWorkspace();
-        const key = recordChannelKey(ws, name);
+        const key = recordChannelKey(ws, nameArg);
         runtime.track(key);
         return variant(runtime.entry(key).status, null);
-      },
-      error: () => {
+      }),
+      RecordBindPrimitives.mutateError.implement((nameArg) => {
         const ws = runtime.resolveWorkspace();
-        const key = recordChannelKey(ws, name);
+        const key = recordChannelKey(ws, nameArg);
         runtime.track(key);
         const entry = runtime.entry(key);
         return entry.status === "failed" && entry.error !== void 0 ? some(entry.error) : none$1;
-      },
-      cancel: () => {
+      }),
+      RecordBindPrimitives.mutateCancel.implement((nameArg) => {
         const ws = runtime.resolveWorkspace();
-        runtime.cancelChannel(recordChannelKey(ws, name), (e3) => {
+        runtime.cancelChannel(recordChannelKey(ws, nameArg), (e3) => {
           delete e3.error;
           delete e3.inflight;
         });
         return null;
-      }
+      }),
+      RecordBindPrimitives.mutate.implement((argsStructType) => (recordNameArg, mutationNameArg, argsStruct) => {
+        const fields = argsStructType.value;
+        const obj = argsStruct;
+        const argTypes = fields.map((f2) => f2.type);
+        const args = fields.map((f2) => obj[f2.name]);
+        runtime.launchMutation(runtime.resolveWorkspace(), recordNameArg, mutationNameArg, argTypes, args);
+        return null;
+      })
+    ];
+  }
+  /**
+   * Build the handle value for one `Record.bind` evaluation. Every method —
+   * top-level AND nested `mutate.*` (incl. the dynamic per-mutation closures) —
+   * is a thin IR-bearing `East.function` over {@link buildPrimitives}, capturing
+   * only the record name (+ per-mutation name), so the handle is ordinary
+   * serializable East data (issue #106).
+   */
+  buildHandle(handleType, name) {
+    const cached = this.handleCache.get(name);
+    if (cached) return cached;
+    const sig = signatureOfRecordHandleType(handleType);
+    const stateTypeEast = fromEastTypeValue(sig.stateType);
+    const fields = handleType.value;
+    const fnOut = (list, n2) => fromEastTypeValue(list.find((f2) => f2.name === n2).type.value.output);
+    const statusRet = fnOut(fields, "status");
+    const historyRet = fnOut(fields, "history");
+    const mfields = fields.find((f2) => f2.name === "mutate").type.value;
+    const nameExpr = East.value(name, StringType);
+    const platform = this.buildPrimitives();
+    const P2 = RecordBindPrimitives;
+    const mutate = {
+      pending: East.compile(East.function([], fnOut(mfields, "pending"), ($3) => {
+        $3.return(P2.mutatePending(nameExpr));
+      }), platform),
+      status: East.compile(East.function([], fnOut(mfields, "status"), ($3) => {
+        $3.return(P2.mutateStatus(nameExpr));
+      }), platform),
+      error: East.compile(East.function([], fnOut(mfields, "error"), ($3) => {
+        $3.return(P2.mutateError(nameExpr));
+      }), platform),
+      cancel: East.compile(East.function([], NullType, ($3) => {
+        $3.return(P2.mutateCancel(nameExpr));
+      }), platform)
     };
     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);
-      },
+      const argTypesEast = argTypes.map((t4) => fromEastTypeValue(t4));
+      const ArgsStruct = StructType(Object.fromEntries(argTypesEast.map((t4, i) => [`arg${i}`, t4])));
+      const mutationNameExpr = East.value(mutationName, StringType);
+      mutate[mutationName] = East.compile(East.function(argTypesEast, NullType, ($3, ...args) => {
+        const obj = {};
+        args.forEach((a2, i) => {
+          obj[`arg${i}`] = a2;
+        });
+        $3.return(P2.mutate([ArgsStruct], nameExpr, mutationNameExpr, East.value(obj, ArgsStruct)));
+      }), platform);
+    }
+    const handle = {
+      read: East.compile(East.function([], stateTypeEast, ($3) => {
+        $3.return(P2.read([stateTypeEast], nameExpr));
+      }), platform),
+      status: East.compile(East.function([], statusRet, ($3) => {
+        $3.return(P2.status(nameExpr));
+      }), platform),
+      history: East.compile(East.function([], historyRet, ($3) => {
+        $3.return(P2.history(nameExpr));
+      }), platform),
       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;
-      },
+      start: East.compile(East.function([], NullType, ($3) => {
+        $3.return(P2.start(nameExpr));
+      }), platform),
       binding: { name, mutations: [...sig.mutations.keys()] }
     };
+    this.handleCache.set(name, handle);
+    return handle;
   }
   // ----- platform building -------------------------------------------------
   /** Build a `Record.bind` PlatformFunction bound to this runtime. Pass
@@ -7902,9 +8170,15 @@ function initializeRecordApi(api3, cache3, workspace) {
 function clearRecordApi() {
   defaultRecordRuntime.clear();
 }
-const RecordPlatform = [defaultRecordRuntime.buildPlatform(null)];
+const RecordPlatform = [
+  defaultRecordRuntime.buildPlatform(null),
+  ...defaultRecordRuntime.buildPrimitives()
+];
 function createScopedRecordPlatform(records) {
-  return [defaultRecordRuntime.buildPlatform(new Set(records))];
+  return [
+    defaultRecordRuntime.buildPlatform(new Set(records)),
+    ...defaultRecordRuntime.buildPrimitives()
+  ];
 }
 function createInMemoryRecordApi(cache3, workspace, defs2) {
   const compiled = /* @__PURE__ */ new Map();
@@ -61612,23 +61886,23 @@ function hashString2(s2) {
   for (let i = 0; i < s2.length; i++) h2 = (h2 << 5) + h2 + s2.charCodeAt(i) | 0;
   return (h2 >>> 0).toString(36);
 }
-function buildDecisionHandle(decisions, judgements, sliceInit) {
-  const selectionKey = deriveSelectionKey(decisions);
-  const readSelection = () => {
-    StateRuntime.trackKey(selectionKey);
-    const bytes = StateRuntime.getStore().read(selectionKey);
-    return bytes === void 0 ? none$1 : decodeSelection(bytes);
-  };
-  const writeSelection = (value) => {
-    StateRuntime.getStore().write(selectionKey, encodeSelection(value));
-    return null;
-  };
-  const queue = () => decisions.flatMap((b2) => viewFor(b2).read());
-  const readJudgements = () => viewFor(judgements).read();
-  const writeJudgements = (next2) => {
-    viewFor(judgements).write(next2);
-  };
-  const judgementFor = (caseId) => readJudgements().get(caseId) ?? {
+function readSelectionAt(selectionKey) {
+  StateRuntime.trackKey(selectionKey);
+  const bytes = StateRuntime.getStore().read(selectionKey);
+  return bytes === void 0 ? none$1 : decodeSelection(bytes);
+}
+function writeSelectionAt(selectionKey, value) {
+  StateRuntime.getStore().write(selectionKey, encodeSelection(value));
+  return null;
+}
+function hostQueue(decisions) {
+  return decisions.flatMap((b2) => viewFor(b2).read());
+}
+function readJudgementsAt(judgements) {
+  return viewFor(judgements).read();
+}
+function judgementForAt(judgements, caseId) {
+  return readJudgementsAt(judgements).get(caseId) ?? {
     caseId,
     answers: /* @__PURE__ */ new Map(),
     knowledge: none$1,
@@ -61636,101 +61910,190 @@ function buildDecisionHandle(decisions, judgements, sliceInit) {
     verdict: none$1,
     resolvedAt: none$1
   };
-  const stageJudgement = (caseId, change) => {
-    const dict = new Map(readJudgements());
-    dict.set(caseId, { ...judgementFor(caseId), ...change });
-    writeJudgements(dict);
-    return null;
-  };
-  const removeFromOwningView = (caseId) => {
-    for (const binding of decisions) {
-      const view = viewFor(binding);
-      const rows = view.read();
-      if (rows.some((d2) => d2.id === caseId)) {
-        view.write(rows.filter((d2) => d2.id !== caseId));
-      }
+}
+function stageJudgementAt(judgements, caseId, change) {
+  const dict = new Map(readJudgementsAt(judgements));
+  dict.set(caseId, { ...judgementForAt(judgements, caseId), ...change });
+  viewFor(judgements).write(dict);
+  return null;
+}
+function removeFromOwningView(decisions, caseId) {
+  for (const binding of decisions) {
+    const view = viewFor(binding);
+    const rows = view.read();
+    if (rows.some((d2) => d2.id === caseId)) {
+      view.write(rows.filter((d2) => d2.id !== caseId));
     }
-  };
+  }
+}
+const decisionHandleCache = /* @__PURE__ */ new Map();
+function typeToken(tv) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(tv, (_k, v3) => {
+    if (typeof v3 === "object" && v3 !== null) {
+      if (seen.has(v3)) return "<cyc>";
+      seen.add(v3);
+    }
+    return typeof v3 === "bigint" ? `${v3}n` : v3;
+  });
+}
+function compileDecisionMethods(constraintType, decisions, judgements, selectionKey) {
+  const platform = getRegisteredPlatformImplementations();
+  const c2 = fromEastTypeValue(constraintType);
+  const decisionsExpr = East.value(decisions, ArrayType(DiffBindingType));
+  const judgementsExpr = East.value(judgements, DiffBindingType);
+  const selKeyExpr = East.value(selectionKey, StringType);
+  const {
+    queue,
+    selected: selected2,
+    select: select2,
+    clearSelection,
+    decision,
+    update: update2,
+    judgement,
+    answer,
+    addKnowledge,
+    inject,
+    resolve: resolve2,
+    commitState
+  } = DecisionBindPrimitives;
+  return {
+    queue: East.compile(East.function([], ArrayType(DecisionType), ($3) => {
+      $3.return(queue(decisionsExpr));
+    }), platform),
+    selected: East.compile(East.function([], OptionType(StringType), ($3) => {
+      $3.return(selected2(selKeyExpr));
+    }), platform),
+    select: East.compile(East.function([StringType], NullType, ($3, id3) => {
+      $3.return(select2(selKeyExpr, id3));
+    }), platform),
+    clearSelection: East.compile(East.function([], NullType, ($3) => {
+      $3.return(clearSelection(selKeyExpr));
+    }), platform),
+    decision: East.compile(East.function([], OptionType(DecisionType), ($3) => {
+      $3.return(decision(decisionsExpr, selKeyExpr));
+    }), platform),
+    update: East.compile(East.function([DecisionType], NullType, ($3, edited) => {
+      $3.return(update2(decisionsExpr, edited));
+    }), platform),
+    judgement: East.compile(East.function([StringType], judgementInputType(c2), ($3, id3) => {
+      $3.return(judgement([c2], judgementsExpr, id3));
+    }), platform),
+    answer: East.compile(East.function([StringType, StringType, AnswerType], NullType, ($3, id3, prompt, ans) => {
+      $3.return(answer(judgementsExpr, id3, prompt, ans));
+    }), platform),
+    addKnowledge: East.compile(East.function([StringType, StringType], NullType, ($3, id3, text) => {
+      $3.return(addKnowledge(judgementsExpr, id3, text));
+    }), platform),
+    inject: East.compile(East.function([StringType, c2], NullType, ($3, id3, con) => {
+      $3.return(inject([c2], judgementsExpr, id3, con));
+    }), platform),
+    resolve: East.compile(East.function([StringType, VerdictType], NullType, ($3, id3, verdict) => {
+      $3.return(resolve2(decisionsExpr, judgementsExpr, selKeyExpr, id3, verdict));
+    }), platform),
+    commitState: East.compile(East.function([StringType], CommitStateType, ($3, id3) => {
+      $3.return(commitState(decisionsExpr, judgementsExpr, id3));
+    }), platform)
+  };
+}
+function buildDecisionHandle(decisions, judgements, sliceInit, constraintType) {
+  const cType = constraintType ?? toEastTypeValue(DecisionConstraintType);
+  const selectionKey = deriveSelectionKey(decisions);
   const slice3 = buildSliceHandle(
     deriveSliceKey(decisions, sliceInit),
     DECISION_SLICE_CONFIG,
     sliceInit ?? DEFAULT_SLICE_STATE,
-    () => queue(),
+    () => hostQueue(decisions),
     none$1
   );
+  const journal = () => {
+    const entries = [...readJudgementsAt(judgements).values()].filter((j2) => j2.verdict.type === "some");
+    const at = (j2) => j2.resolvedAt.type === "some" ? j2.resolvedAt.value.getTime() : 0;
+    return entries.sort((a2, b2) => at(b2) - at(a2));
+  };
+  const cacheKey = `${hashString2(stableStringify({ decisions, judgements }))}|${typeToken(cType)}`;
+  let methods = decisionHandleCache.get(cacheKey);
+  if (methods === void 0) {
+    methods = compileDecisionMethods(cType, decisions, judgements, selectionKey);
+    decisionHandleCache.set(cacheKey, methods);
+  }
   return {
     decisions,
     judgements,
     sliceInit: sliceInit !== void 0 ? some(sliceInit) : none$1,
     slice: slice3,
-    queue,
-    selected: readSelection,
-    select: (caseId) => writeSelection(some(caseId)),
-    clearSelection: () => writeSelection(none$1),
-    decision: () => {
-      const selection2 = readSelection();
-      if (selection2.type === "none") return none$1;
-      const found = queue().find((d2) => d2.id === selection2.value);
-      return found === void 0 ? none$1 : some(found);
-    },
-    update: (edited) => {
-      for (const binding of decisions) {
-        const view = viewFor(binding);
-        const rows = view.read();
-        if (rows.some((d2) => d2.id === edited.id)) {
-          view.write(rows.map((d2) => d2.id === edited.id ? edited : d2));
-        }
-      }
-      return null;
-    },
-    judgement: judgementFor,
-    answer: (caseId, prompt, response) => {
-      const answers = new Map(judgementFor(caseId).answers);
-      answers.set(prompt, response);
-      return stageJudgement(caseId, { answers });
-    },
-    addKnowledge: (caseId, text) => stageJudgement(caseId, { knowledge: some(text) }),
-    inject: (caseId, constraint) => {
-      const constraints = judgementFor(caseId).constraints.filter((c2) => c2.type !== constraint.type).concat([constraint]);
-      return stageJudgement(caseId, { constraints });
-    },
-    resolve: (caseId, verdict) => {
-      stageJudgement(caseId, { verdict: some(verdict), resolvedAt: some(/* @__PURE__ */ new Date()) });
-      removeFromOwningView(caseId);
-      writeSelection(none$1);
-      return null;
-    },
-    journal: () => {
-      const entries = [...readJudgements().values()].filter((j2) => j2.verdict.type === "some");
-      const at = (j2) => j2.resolvedAt.type === "some" ? j2.resolvedAt.value.getTime() : 0;
-      return entries.sort((a2, b2) => at(b2) - at(a2));
-    },
-    commitState: (caseId) => {
-      const decision = queue().find((d2) => d2.id === caseId);
-      const prompts = (decision == null ? void 0 : decision.prompts) ?? [];
-      const answers = judgementFor(caseId).answers;
-      const responses = prompts.map((p2) => {
-        var _a2;
-        return (_a2 = answers.get(p2.id)) == null ? void 0 : _a2.type;
-      });
-      if (responses.some((r2) => r2 === "no")) return variant("blocked", null);
-      if (responses.some((r2) => r2 === "unknown")) return variant("handoff", null);
-      const unanswered = responses.filter((r2) => r2 === void 0).length;
-      if (unanswered > 0) return variant("gated", BigInt(unanswered));
-      return variant("ready", null);
-    }
+    journal,
+    ...methods
   };
 }
 const DecisionBindPlatform = [
-  // Generic over the constraint contract — the type argument resolver
-  // receives the contract type value; the JS impl is type-agnostic.
-  decisionBindPlatformFn.implement((_constraintType) => (decisionsArg, judgementsArg, sliceInitArg) => buildDecisionHandle(
+  // Generic over the constraint contract — the resolver receives the contract
+  // type value and threads it into the IR-bearing judgement / inject methods.
+  decisionBindPlatformFn.implement((constraintType) => (decisionsArg, judgementsArg, sliceInitArg) => buildDecisionHandle(
     decisionsArg,
     judgementsArg,
-    getSomeorUndefined(sliceInitArg)
-  ))
+    getSomeorUndefined$1(sliceInitArg),
+    constraintType
+  )),
+  // ── issue #106 primitives — host I/O backing the IR-bearing handle methods.
+  // Each is a faithful lift of the original closure body, taking the plain-data
+  // descriptor(s) + the selection key as arguments. ──
+  DecisionBindPrimitives.queue.implement((decisions) => hostQueue(decisions)),
+  DecisionBindPrimitives.selected.implement((selectionKey) => readSelectionAt(selectionKey)),
+  DecisionBindPrimitives.select.implement((selectionKey, caseId) => writeSelectionAt(selectionKey, some(caseId))),
+  DecisionBindPrimitives.clearSelection.implement((selectionKey) => writeSelectionAt(selectionKey, none$1)),
+  DecisionBindPrimitives.decision.implement((decisions, selectionKey) => {
+    const sel = readSelectionAt(selectionKey);
+    if (sel.type === "none") return none$1;
+    const found = hostQueue(decisions).find((d2) => d2.id === sel.value);
+    return found === void 0 ? none$1 : some(found);
+  }),
+  DecisionBindPrimitives.update.implement((decisions, edited) => {
+    const e3 = edited;
+    for (const binding of decisions) {
+      const view = viewFor(binding);
+      const rows = view.read();
+      if (rows.some((d2) => d2.id === e3.id)) {
+        view.write(rows.map((d2) => d2.id === e3.id ? e3 : d2));
+      }
+    }
+    return null;
+  }),
+  DecisionBindPrimitives.judgement.implement((_c2) => (judgements, caseId) => judgementForAt(judgements, caseId)),
+  DecisionBindPrimitives.answer.implement((judgements, caseId, prompt, response) => {
+    const answers = new Map(judgementForAt(judgements, caseId).answers);
+    answers.set(prompt, response);
+    return stageJudgementAt(judgements, caseId, { answers });
+  }),
+  DecisionBindPrimitives.addKnowledge.implement((judgements, caseId, text) => stageJudgementAt(judgements, caseId, { knowledge: some(text) })),
+  DecisionBindPrimitives.inject.implement((_c2) => (judgements, caseId, constraint) => {
+    const con = constraint;
+    const constraints = judgementForAt(judgements, caseId).constraints.filter((x2) => x2.type !== con.type).concat([con]);
+    return stageJudgementAt(judgements, caseId, { constraints });
+  }),
+  DecisionBindPrimitives.resolve.implement((decisions, judgements, selectionKey, caseId, verdict) => {
+    stageJudgementAt(judgements, caseId, { verdict: some(verdict), resolvedAt: some(/* @__PURE__ */ new Date()) });
+    removeFromOwningView(decisions, caseId);
+    writeSelectionAt(selectionKey, none$1);
+    return null;
+  }),
+  DecisionBindPrimitives.commitState.implement((decisions, judgements, caseId) => {
+    const cid = caseId;
+    const decision = hostQueue(decisions).find((d2) => d2.id === cid);
+    const prompts = (decision == null ? void 0 : decision.prompts) ?? [];
+    const answers = judgementForAt(judgements, cid).answers;
+    const responses = prompts.map((p2) => {
+      var _a2;
+      return (_a2 = answers.get(p2.id)) == null ? void 0 : _a2.type;
+    });
+    if (responses.some((r2) => r2 === "no")) return variant("blocked", null);
+    if (responses.some((r2) => r2 === "unknown")) return variant("handoff", null);
+    const unanswered = responses.filter((r2) => r2 === void 0).length;
+    if (unanswered > 0) return variant("gated", BigInt(unanswered));
+    return variant("ready", null);
+  })
 ];
-registerPlatformImplementation$1(DecisionBindPlatform);
+registerPlatformImplementation(DecisionBindPlatform);
 function useHandleVersion(handle) {
   const staged = getStagedStore();
   const cache3 = getReactiveDatasetCache();
@@ -61766,7 +62129,7 @@ function useDecisionHandle(ref) {
     () => ref ? buildDecisionHandle(
       [...ref.decisions],
       ref.judgements,
-      getSomeorUndefined(ref.slice)
+      getSomeorUndefined$1(ref.slice)
     ) : null,
     [ref]
   );
@@ -62116,6 +62479,9 @@ const OptionsFacet = memo(function OptionsFacet2({ decision, narrow }) {
   const options2 = rankOptions(decision);
   const maxUp = Math.max(...options2.map((o2) => Math.max(o2.value, 0)), 1e-9);
   const maxDown = Math.max(...options2.map((o2) => Math.abs(o2.downside ?? 0)), 1e-9);
+  const valueAxis = getSomeorUndefined(decision.valueAxis);
+  const upLabel = (valueAxis == null ? void 0 : valueAxis.label) ?? "Uplift";
+  const signed2 = (valueAxis == null ? void 0 : valueAxis.signed) ?? true;
   if (narrow) {
     const meter = (label, frac, display, tone) => /* @__PURE__ */ jsxs(Box, { display: "grid", gridTemplateColumns: "80px 1fr 64px", alignItems: "center", gap: "8px", children: [
       /* @__PURE__ */ jsx$1(Text, { ...caption, whiteSpace: "nowrap", children: label }),
@@ -62134,7 +62500,7 @@ const OptionsFacet = memo(function OptionsFacet2({ decision, narrow }) {
           " ",
           /* @__PURE__ */ jsx$1(Text, { as: "span", fontWeight: o2.recommended ? "semibold" : "normal", children: o2.label })
         ] }),
-        meter("Uplift", o2.value / maxUp, fmt(decision, o2.value, true), "success"),
+        meter(upLabel, o2.value / maxUp, fmt(decision, o2.value, signed2), signed2 ? "success" : "neutral"),
         meter("If wrong", (o2.downside ?? 0) / maxDown, o2.downside !== void 0 ? fmt(decision, o2.downside, true) : "—", "danger")
       ] }, o2.rank))
     ] });
@@ -62147,7 +62513,7 @@ const OptionsFacet = memo(function OptionsFacet2({ decision, narrow }) {
         " evaluated"
       ] }),
       /* @__PURE__ */ jsx$1(Text, { ...caption, textAlign: "center", children: "If wrong" }),
-      /* @__PURE__ */ jsx$1(Text, { ...caption, textAlign: "right", children: "Uplift" })
+      /* @__PURE__ */ jsx$1(Text, { ...caption, textAlign: "right", children: upLabel })
     ] }),
     options2.map((o2) => {
       const downFrac = Math.min(Math.abs(o2.downside ?? 0) / maxDown, 1);
@@ -62172,8 +62538,8 @@ const OptionsFacet = memo(function OptionsFacet2({ decision, narrow }) {
               /* @__PURE__ */ jsx$1(Box, { height: "12px", width: `${Math.round(downFrac * 100)}%`, bg: "fg.danger", opacity: 0.55 })
             ] }) }),
             /* @__PURE__ */ jsx$1(Box, { display: "flex", alignItems: "center", gap: "6px", height: "16px", borderLeftWidth: "1px", borderColor: "border.strong", children: o2.value > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
-              /* @__PURE__ */ jsx$1(Box, { height: "12px", width: `${Math.round(upFrac * 100)}%`, bg: "fg.success", opacity: 0.6 }),
-              /* @__PURE__ */ jsx$1(Text, { fontSize: "10.5px", fontFamily: "mono", color: "fg.success", flexShrink: 0, children: fmt(decision, o2.value, true) })
+              /* @__PURE__ */ jsx$1(Box, { height: "12px", width: `${Math.round(upFrac * 100)}%`, bg: signed2 ? "fg.success" : "fg.subtle", opacity: 0.6 }),
+              /* @__PURE__ */ jsx$1(Text, { fontSize: "10.5px", fontFamily: "mono", color: signed2 ? "fg.success" : "fg.muted", flexShrink: 0, children: fmt(decision, o2.value, signed2) })
             ] }) })
           ]
         },
@@ -62358,7 +62724,8 @@ function useLeverPayloads(ref) {
     return (constraint == null ? void 0 : constraint.type) === "Variant" ? constraint.cases ?? {} : {};
   }, [ref, workspace]);
 }
-const Row = memo(function Row2({ decision, handle, selected: selected2, narrow, leverPayloads, modify, detail, defaultFacet, apply: apply2, reject: reject2, leaving, storageKey }) {
+const Row = memo(function Row2({ decision, handle, selected: selected2, narrow, leverPayloads, modify, evidence, defaultFacet, facetInclude, apply: apply2, reject: reject2, leaving, storageKey }) {
+  var _a2, _b2;
   const dq = useSlotRecipe({ key: "decisionQueue" });
   const status = useSlotRecipe({ key: "status" });
   const tabs = useSlotRecipe({ key: "facetTabs" });
@@ -62366,10 +62733,15 @@ const Row = memo(function Row2({ decision, handle, selected: selected2, narrow,
   const rs = dq({});
   const ts = tabs({});
   const st = status({ status: URGENCY_TONE[decision.urgency.type], size: "md" });
-  const [facet, setFacet] = useState(defaultFacet);
+  const visibleFacets = useMemo(
+    () => FACETS.filter((f2) => f2.key === "modify" ? modify !== void 0 : facetInclude === null || facetInclude.has(f2.key)),
+    [modify, facetInclude]
+  );
+  const effectiveDefault = visibleFacets.some((f2) => f2.key === defaultFacet) ? defaultFacet : ((_a2 = visibleFacets[0]) == null ? void 0 : _a2.key) ?? defaultFacet;
+  const [facet, setFacet] = useState(effectiveDefault);
   useEffect(() => {
-    if (!selected2) setFacet(defaultFacet);
-  }, [selected2, defaultFacet]);
+    if (!selected2) setFacet(effectiveDefault);
+  }, [selected2, effectiveDefault]);
   const gate = handle.commitStateFor(decision.id);
   const applyEnabled = gate === null || gate.type === "ready";
   const gatePulse = !applyEnabled && decision.prompts.length > 0;
@@ -62388,10 +62760,10 @@ const Row = memo(function Row2({ decision, handle, selected: selected2, narrow,
     return modify(decision, handle.update);
   }, [selected2, facet, modify, decision, handle.update]);
   const canvas = useMemo(() => {
-    if (!selected2 || facet !== "evidence" || !detail) return null;
-    return detail(decision);
-  }, [selected2, facet, detail, decision]);
-  const facetTabs = /* @__PURE__ */ jsx$1(Box, { css: ts.root, ...narrow ? { display: "flex", width: "100%" } : {}, children: FACETS.filter((f2) => f2.key !== "modify" || modify !== void 0).map((f2) => /* @__PURE__ */ jsx$1(
+    if (!selected2 || facet !== "evidence" || !evidence) return null;
+    return evidence(decision);
+  }, [selected2, facet, evidence, decision]);
+  const facetTabs = /* @__PURE__ */ jsx$1(Box, { css: ts.root, ...narrow ? { display: "flex", width: "100%" } : {}, children: visibleFacets.map((f2) => /* @__PURE__ */ jsx$1(
     Box,
     {
       as: "button",
@@ -62437,7 +62809,8 @@ const Row = memo(function Row2({ decision, handle, selected: selected2, narrow,
       deadlineSuffix(decision)
     ] })
   ] });
-  const valueText = /* @__PURE__ */ jsx$1(Text, { fontFamily: "mono", fontWeight: "semibold", textAlign: "right", ...decision.value >= 0 && selected2 ? { color: "fg.success" } : {}, children: decisionValue(decision, decision.value, selected2) });
+  const valueSigned = ((_b2 = getSomeorUndefined(decision.valueAxis)) == null ? void 0 : _b2.signed) ?? true;
+  const valueText = /* @__PURE__ */ jsx$1(Text, { fontFamily: "mono", fontWeight: "semibold", textAlign: "right", ...valueSigned && decision.value >= 0 && selected2 ? { color: "fg.success" } : {}, children: decisionValue(decision, decision.value, valueSigned && selected2) });
   return /* @__PURE__ */ jsxs(Box, { css: rs.rowShell, ...leaving ? { "data-leaving": leaving } : {}, children: [
     narrow ? /* @__PURE__ */ jsxs(Box, { px: "14px", py: "10px", children: [
       /* @__PURE__ */ jsxs(Box, { display: "flex", justifyContent: "space-between", alignItems: "baseline", children: [
@@ -62459,7 +62832,7 @@ const Row = memo(function Row2({ decision, handle, selected: selected2, narrow,
       ] })
     ] }),
     selected2 && /* @__PURE__ */ jsxs(Box, { px: narrow ? "14px" : "18px", py: "12px", borderTopWidth: "1px", borderColor: "border.subtle", bg: "bg.canvas", children: [
-      facet === "evidence" && /* @__PURE__ */ jsx$1(EvidenceFacet, { decision, children: canvas != null && /* @__PURE__ */ jsx$1(EastChakraComponent, { value: canvas, storageKey: `${storageKey}-detail-${decision.id}` }) }),
+      facet === "evidence" && /* @__PURE__ */ jsx$1(EvidenceFacet, { decision, children: canvas != null && /* @__PURE__ */ jsx$1(EastChakraComponent, { value: canvas, storageKey: `${storageKey}-evidence-${decision.id}` }) }),
       facet === "options" && /* @__PURE__ */ jsx$1(OptionsFacet, { decision, narrow }),
       facet === "judgement" && /* @__PURE__ */ jsx$1(JudgementFacet, { decision, handle, leverPayloads }),
       facet === "modify" && probe != null && /* @__PURE__ */ jsx$1(EastChakraComponent, { value: probe, storageKey: `${storageKey}-modify-${decision.id}` })
@@ -62567,11 +62940,15 @@ const EastChakraDecisionQueue = memo(function EastChakraDecisionQueue2({ value,
     () => getSomeorUndefined(value.modify),
     [value.modify]
   );
-  const detail = useMemo(
-    () => getSomeorUndefined(value.detail),
-    [value.detail]
+  const evidence = useMemo(
+    () => getSomeorUndefined(value.evidence),
+    [value.evidence]
   );
   const defaultFacet = ((_a2 = getSomeorUndefined(value.defaultFacet)) == null ? void 0 : _a2.type) ?? "evidence";
+  const facetInclude = useMemo(() => {
+    const facets = getSomeorUndefined(value.facets);
+    return facets === void 0 ? null : new Set(facets.map((f2) => f2.type));
+  }, [value.facets]);
   const defaultExpanded = getSomeorUndefined(value.defaultExpanded);
   const selectedId = handle.selected ?? (defaultExpanded == null ? void 0 : defaultExpanded.id) ?? null;
   const resolve2 = useCallback((ds, hook2, reason) => {
@@ -62658,8 +63035,9 @@ const EastChakraDecisionQueue = memo(function EastChakraDecisionQueue2({ value,
               narrow,
               leverPayloads,
               modify,
-              detail,
+              evidence,
               defaultFacet,
+              facetInclude,
               apply: apply2,
               reject: reject2,
               leaving: exitingReasons.get(d2.id),