@elaraai/e3-ui-components 1.0.26 → 1.0.27

package/dist/index.cjs

@@ -21,9 +21,10 @@ 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;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const east = require("@elaraai/east");
-const internal$1 = require("@elaraai/east/internal");
-const internal = require("@elaraai/e3-ui/internal");
+const internal = require("@elaraai/east/internal");
+const internal$1 = require("@elaraai/e3-ui/internal");
 const platform = require("@elaraai/east-ui-components/platform");
+const e3Types = require("@elaraai/e3-types");
 const e3ApiClient = require("@elaraai/e3-api-client");
 const jsxRuntime = require("react/jsx-runtime");
 const React = require("react");
@@ -2882,10 +2883,10 @@ function clearStagedStoreSingleton() {
 }
 const UNCHANGED_VARIANT = east.variant("unchanged", null);
 const blobEqual = east.equalFor(east.BlobType);
-const eastTypeEqual$2 = east.equalFor(internal$1.EastTypeType);
+const eastTypeEqual$2 = east.equalFor(internal.EastTypeType);
 const helpersCache = new east.SortedMap(
   void 0,
-  east.compareFor(internal$1.EastTypeType)
+  east.compareFor(internal.EastTypeType)
 );
 function getBindingHelpers(sourceType) {
   let cached = helpersCache.get(sourceType);
@@ -2934,6 +2935,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 east.SortedMap(
+      void 0,
+      east.compareFor(internal.EastTypeType)
+    ));
     this.staged = staged;
     this.staged.onPersistError((_key, err) => this.emitWriteError(err));
   }
@@ -2964,6 +2976,7 @@ class BindRuntime {
   clearCache() {
     this.cache = null;
     this.clearPendingWrites();
+    this.handleCache.clear();
   }
   // ----- pending writes queue -------------------------------------------
   /** Subscribe to write-queue errors. Returns an unsubscribe fn. */
@@ -3090,13 +3103,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();
@@ -3120,6 +3134,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 = east.fromEastTypeValue(sourceType);
+    const srcExpr = east.East.value(sourcePath, e3Types.TreePathType);
+    const patchExpr = east.East.value(patchPath !== void 0 ? east.some(patchPath) : east.none, east.OptionType(e3Types.TreePathType));
+    const modeExpr = east.East.value(east.variant(mode, null), internal$1.DataBindModeType);
+    const platform2 = this.buildPrimitives();
+    const P2 = internal$1.DataBindPrimitives;
+    const handle = {
+      read: east.East.compile(east.East.function([], T2, ($3) => {
+        $3.return(P2.read([T2], srcExpr, patchExpr, modeExpr));
+      }), platform2),
+      write: east.East.compile(east.East.function([T2], east.NullType, ($3, v3) => {
+        $3.return(P2.write([T2], srcExpr, patchExpr, modeExpr, v3));
+      }), platform2),
+      writeAndStart: east.East.compile(east.East.function([T2], east.NullType, ($3, v3) => {
+        $3.return(P2.writeAndStart([T2], srcExpr, patchExpr, modeExpr, v3));
+      }), platform2),
+      start: east.East.compile(east.East.function([], east.NullType, ($3) => {
+        $3.return(P2.start([T2], srcExpr, patchExpr, modeExpr));
+      }), platform2),
+      source: east.East.compile(east.East.function([], T2, ($3) => {
+        $3.return(P2.source([T2], srcExpr, patchExpr, modeExpr));
+      }), platform2),
+      pending: east.East.compile(east.East.function([], east.BooleanType, ($3) => {
+        $3.return(P2.pending([T2], srcExpr, patchExpr, modeExpr));
+      }), platform2),
+      commit: east.East.compile(east.East.function([], east.NullType, ($3) => {
+        $3.return(P2.commit([T2], srcExpr, patchExpr, modeExpr));
+      }), platform2),
+      discard: east.East.compile(east.East.function([], east.NullType, ($3) => {
+        $3.return(P2.discard([T2], srcExpr, patchExpr, modeExpr));
+      }), platform2),
+      has: east.East.compile(east.East.function([], east.BooleanType, ($3) => {
+        $3.return(P2.has([T2], srcExpr, patchExpr, modeExpr));
+      }), platform2),
+      status: east.East.compile(east.East.function([], e3Types.DatasetStatusType, ($3) => {
+        $3.return(P2.status([T2], srcExpr, patchExpr, modeExpr));
+      }), platform2),
+      binding: {
+        source: sourcePath,
+        patch: patchPath !== void 0 ? east.some(patchPath) : east.none,
+        mode: east.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 = internal$1.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,
@@ -3359,7 +3473,7 @@ class BindRuntime {
    *  Pass `allowed=null` for an unscoped impl (the global
    *  `BindPlatform`); pass a Set for manifest scoping. */
   buildPlatform(allowed) {
-    return internal.bindPlatformFn.implement(
+    return internal$1.bindPlatformFn.implement(
       (sourceType) => (sourcePathArg, patchOpt, modeVariant) => {
         const sourcePath = sourcePathArg;
         const { patchPath, mode } = resolveOptions(patchOpt, modeVariant);
@@ -3434,10 +3548,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);
@@ -3586,7 +3706,7 @@ function createDefaultFunctionApi(apiUrl, repo, getToken) {
     }
   };
 }
-const eastTypeEqual$1 = east.equalFor(internal$1.EastTypeType);
+const eastTypeEqual$1 = east.equalFor(internal.EastTypeType);
 function signatureOfFuncHandleType(handleType) {
   var _a2, _b2;
   if (handleType.type !== "Struct") {
@@ -3667,6 +3787,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 };
@@ -3684,6 +3809,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) {
@@ -3787,9 +3913,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) {
@@ -3797,49 +3929,98 @@ 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.
+      internal$1.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();
+      }),
+      internal$1.FuncBindPrimitives.read.implement((_outputType) => (nameArg) => {
+        const { key, entry } = channel(nameArg);
         runtime.track(key);
         return entry.result !== void 0 ? east.variant("some", entry.result) : east.variant("none", null);
-      },
-      status: () => {
-        const { key, entry } = channel();
+      }),
+      internal$1.FuncBindPrimitives.status.implement((nameArg) => {
+        const { key, entry } = channel(nameArg);
         runtime.track(key);
         return east.variant(entry.status, null);
-      },
-      error: () => {
-        const { key, entry } = channel();
+      }),
+      internal$1.FuncBindPrimitives.error.implement((nameArg) => {
+        const { key, entry } = channel(nameArg);
         runtime.track(key);
         return entry.status === "failed" && entry.error !== void 0 ? east.variant("some", entry.error) : east.variant("none", null);
-      },
-      pending: () => {
-        const { key, entry } = channel();
+      }),
+      internal$1.FuncBindPrimitives.pending.implement((nameArg) => {
+        const { key, entry } = channel(nameArg);
         runtime.track(key);
         return entry.status === "running";
-      },
-      cancel: () => {
-        const { key } = channel();
+      }),
+      internal$1.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) => east.fromEastTypeValue(t4));
+    const outputEast = east.fromEastTypeValue(sig.output);
+    const ArgsStruct = east.StructType(Object.fromEntries(inputsEast.map((t4, i) => [`arg${i}`, t4])));
+    const nameExpr = east.East.value(name, east.StringType);
+    const platform2 = this.buildPrimitives();
+    const { call, read, status, error: error3, pending, cancel } = internal$1.FuncBindPrimitives;
+    const handle = {
+      call: east.East.compile(east.East.function(inputsEast, east.NullType, ($3, ...args) => {
+        const obj = {};
+        args.forEach((a2, i) => {
+          obj[`arg${i}`] = a2;
+        });
+        $3.return(call([ArgsStruct, outputEast], nameExpr, east.East.value(obj, ArgsStruct)));
+      }), platform2),
+      read: east.East.compile(east.East.function([], east.OptionType(outputEast), ($3) => {
+        $3.return(read([outputEast], nameExpr));
+      }), platform2),
+      status: east.East.compile(east.East.function([], internal$1.FuncStatusType, ($3) => {
+        $3.return(status(nameExpr));
+      }), platform2),
+      error: east.East.compile(east.East.function([], east.OptionType(internal$1.FuncErrorType), ($3) => {
+        $3.return(error3(nameExpr));
+      }), platform2),
+      pending: east.East.compile(east.East.function([], east.BooleanType, ($3) => {
+        $3.return(pending(nameExpr));
+      }), platform2),
+      cancel: east.East.compile(east.East.function([], east.NullType, ($3) => {
+        $3.return(cancel(nameExpr));
+      }), platform2),
       binding: { name }
     };
+    this.handleCache.set(name, handle);
+    return handle;
   }
   // ----- platform building -------------------------------------------------
   /** Build a `Func.bind` PlatformFunction bound to this runtime. Pass
    *  `allowed=null` for an unscoped impl; pass a Set of function names
    *  for manifest scoping. */
   buildPlatform(allowed) {
-    return internal.funcBindPlatformFn.implement(
+    return internal$1.funcBindPlatformFn.implement(
       (handleType) => (nameArg) => {
         const name = nameArg;
         if (allowed && !allowed.has(name)) {
@@ -3859,9 +4040,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) => ({
@@ -7586,7 +7773,7 @@ function createDefaultRecordApi(apiUrl, repo, getToken) {
     }
   };
 }
-const eastTypeEqual = east.equalFor(internal$1.EastTypeType);
+const eastTypeEqual = east.equalFor(internal.EastTypeType);
 const RESERVED_MUTATE_FIELDS = /* @__PURE__ */ new Set(["pending", "status", "error", "cancel"]);
 function signatureOfRecordHandleType(handleType) {
   var _a2, _b2;
@@ -7671,6 +7858,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 };
@@ -7693,6 +7886,7 @@ class RecordRuntime extends TrackedChannelStore {
     this.histories.clear();
     this.historyInFlight.clear();
     this.historyFailed.clear();
+    this.handleCache.clear();
   }
   resolveWorkspace() {
     if (!this.workspace) {
@@ -7811,96 +8005,170 @@ 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 = east.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 [
+      internal$1.RecordBindPrimitives.read.implement((stateType) => {
+        const decode = east.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);
+        };
+      }),
+      internal$1.RecordBindPrimitives.status.implement((nameArg) => {
+        const ws = runtime.resolveWorkspace();
+        const path2 = recordPath(nameArg);
+        trackDatasetPath(ws, path2);
+        return requireCache().getStatus(ws, path2);
+      }),
+      internal$1.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 east.none;
+        }
+        return east.some(cached);
+      }),
+      internal$1.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;
+      }),
+      internal$1.RecordBindPrimitives.mutatePending.implement((nameArg) => {
+        const ws = runtime.resolveWorkspace();
+        const key = recordChannelKey(ws, nameArg);
+        runtime.track(key);
         return runtime.entry(key).status === "running";
-      },
-      status: () => {
+      }),
+      internal$1.RecordBindPrimitives.mutateStatus.implement((nameArg) => {
         const ws = runtime.resolveWorkspace();
-        const key = recordChannelKey(ws, name);
+        const key = recordChannelKey(ws, nameArg);
         runtime.track(key);
         return east.variant(runtime.entry(key).status, null);
-      },
-      error: () => {
+      }),
+      internal$1.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 ? east.some(entry.error) : east.none;
-      },
-      cancel: () => {
+      }),
+      internal$1.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;
-      }
+      }),
+      internal$1.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 = east.fromEastTypeValue(sig.stateType);
+    const fields = handleType.value;
+    const fnOut = (list, n2) => east.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.East.value(name, east.StringType);
+    const platform2 = this.buildPrimitives();
+    const P2 = internal$1.RecordBindPrimitives;
+    const mutate = {
+      pending: east.East.compile(east.East.function([], fnOut(mfields, "pending"), ($3) => {
+        $3.return(P2.mutatePending(nameExpr));
+      }), platform2),
+      status: east.East.compile(east.East.function([], fnOut(mfields, "status"), ($3) => {
+        $3.return(P2.mutateStatus(nameExpr));
+      }), platform2),
+      error: east.East.compile(east.East.function([], fnOut(mfields, "error"), ($3) => {
+        $3.return(P2.mutateError(nameExpr));
+      }), platform2),
+      cancel: east.East.compile(east.East.function([], east.NullType, ($3) => {
+        $3.return(P2.mutateCancel(nameExpr));
+      }), platform2)
     };
     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 east.none;
-        }
-        return east.some(cached);
-      },
+      const argTypesEast = argTypes.map((t4) => east.fromEastTypeValue(t4));
+      const ArgsStruct = east.StructType(Object.fromEntries(argTypesEast.map((t4, i) => [`arg${i}`, t4])));
+      const mutationNameExpr = east.East.value(mutationName, east.StringType);
+      mutate[mutationName] = east.East.compile(east.East.function(argTypesEast, east.NullType, ($3, ...args) => {
+        const obj = {};
+        args.forEach((a2, i) => {
+          obj[`arg${i}`] = a2;
+        });
+        $3.return(P2.mutate([ArgsStruct], nameExpr, mutationNameExpr, east.East.value(obj, ArgsStruct)));
+      }), platform2);
+    }
+    const handle = {
+      read: east.East.compile(east.East.function([], stateTypeEast, ($3) => {
+        $3.return(P2.read([stateTypeEast], nameExpr));
+      }), platform2),
+      status: east.East.compile(east.East.function([], statusRet, ($3) => {
+        $3.return(P2.status(nameExpr));
+      }), platform2),
+      history: east.East.compile(east.East.function([], historyRet, ($3) => {
+        $3.return(P2.history(nameExpr));
+      }), platform2),
       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.East.compile(east.East.function([], east.NullType, ($3) => {
+        $3.return(P2.start(nameExpr));
+      }), platform2),
       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
    *  `allowed=null` for an unscoped impl; pass a Set of record names for
    *  manifest scoping. */
   buildPlatform(allowed) {
-    return internal.recordBindPlatformFn.implement(
+    return internal$1.recordBindPlatformFn.implement(
       (handleType) => (nameArg) => {
         const name = nameArg;
         if (allowed && !allowed.has(name)) {
@@ -7920,9 +8188,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();
@@ -8351,7 +8625,7 @@ function parseManualDraft(leafType, draft) {
     return { ok: false };
   }
 }
-const diffValueEqual = east.equalFor(internal.Diff.Component.schema);
+const diffValueEqual = east.equalFor(internal$1.Diff.Component.schema);
 function getOpt$1(opt) {
   return opt.type === "some" ? opt.value : void 0;
 }
@@ -9339,7 +9613,7 @@ const EastChakraDiff = React.memo(function EastChakraDiff2({ value }) {
 function rowKey(pathStr, leafPath) {
   return `${pathStr}::${leafPath}`;
 }
-eastUiComponents.implementUIComponent(internal.Diff.Component, EastChakraDiff);
+eastUiComponents.implementUIComponent(internal$1.Diff.Component, EastChakraDiff);
 function cc(names) {
   if (typeof names === "string" || typeof names === "number") return "" + names;
   let out = "";
@@ -57250,7 +57524,7 @@ const EastChakraOntology = React.memo(function EastChakraOntology2({ value }) {
     }
   );
 });
-eastUiComponents.implementUIComponent(internal.Ontology.Component, EastChakraOntology);
+eastUiComponents.implementUIComponent(internal$1.Ontology.Component, EastChakraOntology);
 const EMPTY_PATH = [];
 function useBindingVersion(workspace, sourcePath, patchPath) {
   const staged = getStagedStore();
@@ -57317,7 +57591,7 @@ function useFuncCall(name, inputs, output2) {
   );
   const handle = React.useMemo(() => {
     if (!ready4) return null;
-    const handleType = east.toEastTypeValue(internal.FuncBindHandleType(inputs, output2));
+    const handleType = east.toEastTypeValue(internal$1.FuncBindHandleType(inputs, output2));
     return defaultFuncRuntime.buildHandle(handleType, name);
   }, [ready4, name, workspace, sigKey]);
   const channelKey = ready4 ? funcChannelKey(workspace, name) : "";
@@ -60763,7 +61037,7 @@ function LoadingSkeleton() {
     ] })
   ] });
 }
-const experimentValueEqual = east.equalFor(internal.Experiment.Component.schema);
+const experimentValueEqual = east.equalFor(internal$1.Experiment.Component.schema);
 const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }) {
   var _a2, _b2, _c2;
   const v3 = value;
@@ -60832,16 +61106,16 @@ const EastChakraExperiment = React.memo(function EastChakraExperiment2({ value }
     }),
     [columns, meta3]
   );
-  const estInputs = React.useMemo(() => rowArrayType ? [rowArrayType, internal.Experiment.Types.Config] : null, [rowArrayType]);
-  const experiment = useFuncCall(v3.experiment.type === "some" ? v3.experiment.value.name : null, estInputs, internal.Experiment.Types.Result);
+  const estInputs = React.useMemo(() => rowArrayType ? [rowArrayType, internal$1.Experiment.Types.Config] : null, [rowArrayType]);
+  const experiment = useFuncCall(v3.experiment.type === "some" ? v3.experiment.value.name : null, estInputs, internal$1.Experiment.Types.Result);
   const hasExperiment = v3.experiment.type === "some";
   const shownResult = experiment.result ?? eastUiComponents.getSomeorUndefined(selectedEntry == null ? void 0 : selectedEntry.result) ?? null;
   const hasDesign = v3.design.type === "some";
   const designInputs = React.useMemo(
-    () => rowArrayType ? [rowArrayType, internal.Experiment.Types.Config, internal.Experiment.Types.Result, internal.Experiment.Types.DesignConfig] : null,
+    () => rowArrayType ? [rowArrayType, internal$1.Experiment.Types.Config, internal$1.Experiment.Types.Result, internal$1.Experiment.Types.DesignConfig] : null,
     [rowArrayType]
   );
-  const design = useFuncCall(v3.design.type === "some" ? v3.design.value.name : null, designInputs, internal.Experiment.Types.Design);
+  const design = useFuncCall(v3.design.type === "some" ? v3.design.value.name : null, designInputs, internal$1.Experiment.Types.Design);
   const pendingConfigRef = React.useRef(null);
   const [ranConfig, setRanConfig] = React.useState(null);
   const runAll = React.useCallback(() => {
@@ -61582,7 +61856,7 @@ function Segmented({ label, left, right, active, onPick, last: last2, help, read
     readonly ? /* @__PURE__ */ jsxRuntime.jsx(SegmentStatic, { value: active === "left" ? left : right }) : /* @__PURE__ */ jsxRuntime.jsx(SegmentSelect, { options: [left, right], active: active === "left" ? 0 : 1, onPick: (i) => onPick(i === 0 ? "left" : "right"), fill: true, size: "xs" })
   ] });
 }
-eastUiComponents.implementUIComponent(internal.Experiment.Component, EastChakraExperiment);
+eastUiComponents.implementUIComponent(internal$1.Experiment.Component, EastChakraExperiment);
 const SELECTION_TYPE = east.OptionType(east.StringType);
 const encodeSelection = east.encodeBeast2For(SELECTION_TYPE);
 const decodeSelection = east.decodeBeast2For(SELECTION_TYPE);
@@ -61630,23 +61904,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 = () => {
-    eastUiComponents.StateRuntime.trackKey(selectionKey);
-    const bytes = eastUiComponents.StateRuntime.getStore().read(selectionKey);
-    return bytes === void 0 ? east.none : decodeSelection(bytes);
-  };
-  const writeSelection = (value) => {
-    eastUiComponents.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) {
+  platform.StateRuntime.trackKey(selectionKey);
+  const bytes = platform.StateRuntime.getStore().read(selectionKey);
+  return bytes === void 0 ? east.none : decodeSelection(bytes);
+}
+function writeSelectionAt(selectionKey, value) {
+  platform.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: east.none,
@@ -61654,105 +61928,194 @@ function buildDecisionHandle(decisions, judgements, sliceInit) {
     verdict: east.none,
     resolvedAt: east.none
   };
-  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 slice3 = eastUiComponents.buildSliceHandle(
+  }
+}
+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$1 = platform.getRegisteredPlatformImplementations();
+  const c2 = east.fromEastTypeValue(constraintType);
+  const decisionsExpr = east.East.value(decisions, east.ArrayType(internal$1.DiffBindingType));
+  const judgementsExpr = east.East.value(judgements, internal$1.DiffBindingType);
+  const selKeyExpr = east.East.value(selectionKey, east.StringType);
+  const {
+    queue,
+    selected: selected2,
+    select: select2,
+    clearSelection,
+    decision,
+    update: update2,
+    judgement,
+    answer,
+    addKnowledge,
+    inject,
+    resolve: resolve2,
+    commitState
+  } = internal$1.DecisionBindPrimitives;
+  return {
+    queue: east.East.compile(east.East.function([], east.ArrayType(internal$1.DecisionType), ($3) => {
+      $3.return(queue(decisionsExpr));
+    }), platform$1),
+    selected: east.East.compile(east.East.function([], east.OptionType(east.StringType), ($3) => {
+      $3.return(selected2(selKeyExpr));
+    }), platform$1),
+    select: east.East.compile(east.East.function([east.StringType], east.NullType, ($3, id3) => {
+      $3.return(select2(selKeyExpr, id3));
+    }), platform$1),
+    clearSelection: east.East.compile(east.East.function([], east.NullType, ($3) => {
+      $3.return(clearSelection(selKeyExpr));
+    }), platform$1),
+    decision: east.East.compile(east.East.function([], east.OptionType(internal$1.DecisionType), ($3) => {
+      $3.return(decision(decisionsExpr, selKeyExpr));
+    }), platform$1),
+    update: east.East.compile(east.East.function([internal$1.DecisionType], east.NullType, ($3, edited) => {
+      $3.return(update2(decisionsExpr, edited));
+    }), platform$1),
+    judgement: east.East.compile(east.East.function([east.StringType], internal$1.judgementInputType(c2), ($3, id3) => {
+      $3.return(judgement([c2], judgementsExpr, id3));
+    }), platform$1),
+    answer: east.East.compile(east.East.function([east.StringType, east.StringType, internal$1.AnswerType], east.NullType, ($3, id3, prompt, ans) => {
+      $3.return(answer(judgementsExpr, id3, prompt, ans));
+    }), platform$1),
+    addKnowledge: east.East.compile(east.East.function([east.StringType, east.StringType], east.NullType, ($3, id3, text) => {
+      $3.return(addKnowledge(judgementsExpr, id3, text));
+    }), platform$1),
+    inject: east.East.compile(east.East.function([east.StringType, c2], east.NullType, ($3, id3, con) => {
+      $3.return(inject([c2], judgementsExpr, id3, con));
+    }), platform$1),
+    resolve: east.East.compile(east.East.function([east.StringType, internal$1.VerdictType], east.NullType, ($3, id3, verdict) => {
+      $3.return(resolve2(decisionsExpr, judgementsExpr, selKeyExpr, id3, verdict));
+    }), platform$1),
+    commitState: east.East.compile(east.East.function([east.StringType], internal$1.CommitStateType, ($3, id3) => {
+      $3.return(commitState(decisionsExpr, judgementsExpr, id3));
+    }), platform$1)
+  };
+}
+function buildDecisionHandle(decisions, judgements, sliceInit, constraintType) {
+  const cType = constraintType ?? east.toEastTypeValue(internal$1.DecisionConstraintType);
+  const selectionKey = deriveSelectionKey(decisions);
+  const slice3 = platform.buildSliceHandle(
     deriveSliceKey(decisions, sliceInit),
     DECISION_SLICE_CONFIG,
-    sliceInit ?? eastUiComponents.DEFAULT_SLICE_STATE,
-    () => queue(),
+    sliceInit ?? platform.DEFAULT_SLICE_STATE,
+    () => hostQueue(decisions),
     east.none
   );
+  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 ? east.some(sliceInit) : east.none,
     slice: slice3,
-    queue,
-    selected: readSelection,
-    select: (caseId) => writeSelection(east.some(caseId)),
-    clearSelection: () => writeSelection(east.none),
-    decision: () => {
-      const selection2 = readSelection();
-      if (selection2.type === "none") return east.none;
-      const found = queue().find((d2) => d2.id === selection2.value);
-      return found === void 0 ? east.none : east.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: east.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: east.some(verdict), resolvedAt: east.some(/* @__PURE__ */ new Date()) });
-      removeFromOwningView(caseId);
-      writeSelection(east.none);
-      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 east.variant("blocked", null);
-      if (responses.some((r2) => r2 === "unknown")) return east.variant("handoff", null);
-      const unanswered = responses.filter((r2) => r2 === void 0).length;
-      if (unanswered > 0) return east.variant("gated", BigInt(unanswered));
-      return east.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.
-  internal.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.
+  internal$1.decisionBindPlatformFn.implement((constraintType) => (decisionsArg, judgementsArg, sliceInitArg) => buildDecisionHandle(
     decisionsArg,
     judgementsArg,
-    eastUiComponents.getSomeorUndefined(sliceInitArg)
-  ))
+    platform.getSomeorUndefined(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. ──
+  internal$1.DecisionBindPrimitives.queue.implement((decisions) => hostQueue(decisions)),
+  internal$1.DecisionBindPrimitives.selected.implement((selectionKey) => readSelectionAt(selectionKey)),
+  internal$1.DecisionBindPrimitives.select.implement((selectionKey, caseId) => writeSelectionAt(selectionKey, east.some(caseId))),
+  internal$1.DecisionBindPrimitives.clearSelection.implement((selectionKey) => writeSelectionAt(selectionKey, east.none)),
+  internal$1.DecisionBindPrimitives.decision.implement((decisions, selectionKey) => {
+    const sel = readSelectionAt(selectionKey);
+    if (sel.type === "none") return east.none;
+    const found = hostQueue(decisions).find((d2) => d2.id === sel.value);
+    return found === void 0 ? east.none : east.some(found);
+  }),
+  internal$1.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;
+  }),
+  internal$1.DecisionBindPrimitives.judgement.implement((_c2) => (judgements, caseId) => judgementForAt(judgements, caseId)),
+  internal$1.DecisionBindPrimitives.answer.implement((judgements, caseId, prompt, response) => {
+    const answers = new Map(judgementForAt(judgements, caseId).answers);
+    answers.set(prompt, response);
+    return stageJudgementAt(judgements, caseId, { answers });
+  }),
+  internal$1.DecisionBindPrimitives.addKnowledge.implement((judgements, caseId, text) => stageJudgementAt(judgements, caseId, { knowledge: east.some(text) })),
+  internal$1.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 });
+  }),
+  internal$1.DecisionBindPrimitives.resolve.implement((decisions, judgements, selectionKey, caseId, verdict) => {
+    stageJudgementAt(judgements, caseId, { verdict: east.some(verdict), resolvedAt: east.some(/* @__PURE__ */ new Date()) });
+    removeFromOwningView(decisions, caseId);
+    writeSelectionAt(selectionKey, east.none);
+    return null;
+  }),
+  internal$1.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 east.variant("blocked", null);
+    if (responses.some((r2) => r2 === "unknown")) return east.variant("handoff", null);
+    const unanswered = responses.filter((r2) => r2 === void 0).length;
+    if (unanswered > 0) return east.variant("gated", BigInt(unanswered));
+    return east.variant("ready", null);
+  })
 ];
-eastUiComponents.registerPlatformImplementation(DecisionBindPlatform);
+platform.registerPlatformImplementation(DecisionBindPlatform);
 function useHandleVersion(handle) {
   const staged = getStagedStore();
   const cache3 = getReactiveDatasetCache();
-  const state = eastUiComponents.StateRuntime.getStore();
+  const state = platform.StateRuntime.getStore();
   const workspace = cache3.getConfig().workspace ?? "";
   const keys = React.useMemo(() => {
     if (!handle) return [];
@@ -61784,7 +62147,7 @@ function useDecisionHandle(ref) {
     () => ref ? buildDecisionHandle(
       [...ref.decisions],
       ref.judgements,
-      eastUiComponents.getSomeorUndefined(ref.slice)
+      platform.getSomeorUndefined(ref.slice)
     ) : null,
     [ref]
   );
@@ -62134,6 +62497,9 @@ const OptionsFacet = React.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 = eastUiComponents.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__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "80px 1fr 64px", alignItems: "center", gap: "8px", children: [
       /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, whiteSpace: "nowrap", children: label }),
@@ -62152,7 +62518,7 @@ const OptionsFacet = React.memo(function OptionsFacet2({ decision, narrow }) {
           " ",
           /* @__PURE__ */ jsxRuntime.jsx(react.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))
     ] });
@@ -62165,7 +62531,7 @@ const OptionsFacet = React.memo(function OptionsFacet2({ decision, narrow }) {
         " evaluated"
       ] }),
       /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, textAlign: "center", children: "If wrong" }),
-      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, textAlign: "right", children: "Uplift" })
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, textAlign: "right", children: upLabel })
     ] }),
     options2.map((o2) => {
       const downFrac = Math.min(Math.abs(o2.downside ?? 0) / maxDown, 1);
@@ -62190,8 +62556,8 @@ const OptionsFacet = React.memo(function OptionsFacet2({ decision, narrow }) {
               /* @__PURE__ */ jsxRuntime.jsx(react.Box, { height: "12px", width: `${Math.round(downFrac * 100)}%`, bg: "fg.danger", opacity: 0.55 })
             ] }) }),
             /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", alignItems: "center", gap: "6px", height: "16px", borderLeftWidth: "1px", borderColor: "border.strong", children: o2.value > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-              /* @__PURE__ */ jsxRuntime.jsx(react.Box, { height: "12px", width: `${Math.round(upFrac * 100)}%`, bg: "fg.success", opacity: 0.6 }),
-              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "10.5px", fontFamily: "mono", color: "fg.success", flexShrink: 0, children: fmt(decision, o2.value, true) })
+              /* @__PURE__ */ jsxRuntime.jsx(react.Box, { height: "12px", width: `${Math.round(upFrac * 100)}%`, bg: signed2 ? "fg.success" : "fg.subtle", opacity: 0.6 }),
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "10.5px", fontFamily: "mono", color: signed2 ? "fg.success" : "fg.muted", flexShrink: 0, children: fmt(decision, o2.value, signed2) })
             ] }) })
           ]
         },
@@ -62376,7 +62742,8 @@ function useLeverPayloads(ref) {
     return (constraint == null ? void 0 : constraint.type) === "Variant" ? constraint.cases ?? {} : {};
   }, [ref, workspace]);
 }
-const Row = React.memo(function Row2({ decision, handle, selected: selected2, narrow, leverPayloads, modify, detail, defaultFacet, apply: apply2, reject: reject2, leaving, storageKey }) {
+const Row = React.memo(function Row2({ decision, handle, selected: selected2, narrow, leverPayloads, modify, evidence, defaultFacet, facetInclude, apply: apply2, reject: reject2, leaving, storageKey }) {
+  var _a2, _b2;
   const dq = react.useSlotRecipe({ key: "decisionQueue" });
   const status = react.useSlotRecipe({ key: "status" });
   const tabs = react.useSlotRecipe({ key: "facetTabs" });
@@ -62384,10 +62751,15 @@ const Row = React.memo(function Row2({ decision, handle, selected: selected2, na
   const rs = dq({});
   const ts = tabs({});
   const st = status({ status: URGENCY_TONE[decision.urgency.type], size: "md" });
-  const [facet, setFacet] = React.useState(defaultFacet);
+  const visibleFacets = React.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] = React.useState(effectiveDefault);
   React.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;
@@ -62406,10 +62778,10 @@ const Row = React.memo(function Row2({ decision, handle, selected: selected2, na
     return modify(decision, handle.update);
   }, [selected2, facet, modify, decision, handle.update]);
   const canvas = React.useMemo(() => {
-    if (!selected2 || facet !== "evidence" || !detail) return null;
-    return detail(decision);
-  }, [selected2, facet, detail, decision]);
-  const facetTabs = /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: ts.root, ...narrow ? { display: "flex", width: "100%" } : {}, children: FACETS.filter((f2) => f2.key !== "modify" || modify !== void 0).map((f2) => /* @__PURE__ */ jsxRuntime.jsx(
+    if (!selected2 || facet !== "evidence" || !evidence) return null;
+    return evidence(decision);
+  }, [selected2, facet, evidence, decision]);
+  const facetTabs = /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: ts.root, ...narrow ? { display: "flex", width: "100%" } : {}, children: visibleFacets.map((f2) => /* @__PURE__ */ jsxRuntime.jsx(
     react.Box,
     {
       as: "button",
@@ -62455,7 +62827,8 @@ const Row = React.memo(function Row2({ decision, handle, selected: selected2, na
       deadlineSuffix(decision)
     ] })
   ] });
-  const valueText = /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontFamily: "mono", fontWeight: "semibold", textAlign: "right", ...decision.value >= 0 && selected2 ? { color: "fg.success" } : {}, children: decisionValue(decision, decision.value, selected2) });
+  const valueSigned = ((_b2 = eastUiComponents.getSomeorUndefined(decision.valueAxis)) == null ? void 0 : _b2.signed) ?? true;
+  const valueText = /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontFamily: "mono", fontWeight: "semibold", textAlign: "right", ...valueSigned && decision.value >= 0 && selected2 ? { color: "fg.success" } : {}, children: decisionValue(decision, decision.value, valueSigned && selected2) });
   return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: rs.rowShell, ...leaving ? { "data-leaving": leaving } : {}, children: [
     narrow ? /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { px: "14px", py: "10px", children: [
       /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", justifyContent: "space-between", alignItems: "baseline", children: [
@@ -62477,7 +62850,7 @@ const Row = React.memo(function Row2({ decision, handle, selected: selected2, na
       ] })
     ] }),
     selected2 && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { px: narrow ? "14px" : "18px", py: "12px", borderTopWidth: "1px", borderColor: "border.subtle", bg: "bg.canvas", children: [
-      facet === "evidence" && /* @__PURE__ */ jsxRuntime.jsx(EvidenceFacet, { decision, children: canvas != null && /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraComponent, { value: canvas, storageKey: `${storageKey}-detail-${decision.id}` }) }),
+      facet === "evidence" && /* @__PURE__ */ jsxRuntime.jsx(EvidenceFacet, { decision, children: canvas != null && /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraComponent, { value: canvas, storageKey: `${storageKey}-evidence-${decision.id}` }) }),
       facet === "options" && /* @__PURE__ */ jsxRuntime.jsx(OptionsFacet, { decision, narrow }),
       facet === "judgement" && /* @__PURE__ */ jsxRuntime.jsx(JudgementFacet, { decision, handle, leverPayloads }),
       facet === "modify" && probe != null && /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraComponent, { value: probe, storageKey: `${storageKey}-modify-${decision.id}` })
@@ -62585,11 +62958,15 @@ const EastChakraDecisionQueue = React.memo(function EastChakraDecisionQueue2({ v
     () => eastUiComponents.getSomeorUndefined(value.modify),
     [value.modify]
   );
-  const detail = React.useMemo(
-    () => eastUiComponents.getSomeorUndefined(value.detail),
-    [value.detail]
+  const evidence = React.useMemo(
+    () => eastUiComponents.getSomeorUndefined(value.evidence),
+    [value.evidence]
   );
   const defaultFacet = ((_a2 = eastUiComponents.getSomeorUndefined(value.defaultFacet)) == null ? void 0 : _a2.type) ?? "evidence";
+  const facetInclude = React.useMemo(() => {
+    const facets = eastUiComponents.getSomeorUndefined(value.facets);
+    return facets === void 0 ? null : new Set(facets.map((f2) => f2.type));
+  }, [value.facets]);
   const defaultExpanded = eastUiComponents.getSomeorUndefined(value.defaultExpanded);
   const selectedId = handle.selected ?? (defaultExpanded == null ? void 0 : defaultExpanded.id) ?? null;
   const resolve2 = React.useCallback((ds, hook2, reason) => {
@@ -62676,8 +63053,9 @@ const EastChakraDecisionQueue = React.memo(function EastChakraDecisionQueue2({ v
               narrow,
               leverPayloads,
               modify,
-              detail,
+              evidence,
               defaultFacet,
+              facetInclude,
               apply: apply2,
               reject: reject2,
               leaving: exitingReasons.get(d2.id),
@@ -62691,7 +63069,7 @@ const EastChakraDecisionQueue = React.memo(function EastChakraDecisionQueue2({ v
     )
   ] });
 });
-eastUiComponents.implementUIComponent(internal.DecisionQueue.Component, EastChakraDecisionQueue);
+eastUiComponents.implementUIComponent(internal$1.DecisionQueue.Component, EastChakraDecisionQueue);
 function verdictPresentation(verdict) {
   switch (verdict.type) {
     case "accepted":
@@ -62795,7 +63173,7 @@ const EastChakraDecisionJournal = React.memo(function EastChakraDecisionJournal2
     )
   ] });
 });
-eastUiComponents.implementUIComponent(internal.DecisionJournal.Component, EastChakraDecisionJournal);
+eastUiComponents.implementUIComponent(internal$1.DecisionJournal.Component, EastChakraDecisionJournal);
 function formatApiError(error3) {
   if (error3 instanceof e3ApiClient.ApiError && error3.details != null) {
     const details = error3.details;
@@ -63735,7 +64113,7 @@ const UITaskPreview = React.memo(function UITaskPreview2({
   const manifest = React.useMemo(() => {
     if (!details || !isUI) return null;
     const meta3 = getTaskMetadata(details);
-    return meta3 ? internal.decodeManifest(meta3) : { paths: [], functions: [], records: [] };
+    return meta3 ? internal$1.decodeManifest(meta3) : { paths: [], functions: [], records: [] };
   }, [details, isUI]);
   const outputPath = details ? treePathToString$1(details.output) : null;
   const preloads = React.useMemo(