@elaraai/e3-ui-components 1.0.4 → 1.0.6

package/dist/index.cjs

@@ -5,8 +5,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 var _a;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const east = require("@elaraai/east");
-const internal = require("@elaraai/east/internal");
-const e3Ui = require("@elaraai/e3-ui");
+const internal$1 = require("@elaraai/east/internal");
+const internal = require("@elaraai/e3-ui/internal");
 const platform = require("@elaraai/east-ui-components/platform");
 const e3ApiClient = require("@elaraai/e3-api-client");
 const jsxRuntime = require("react/jsx-runtime");
@@ -14,6 +14,7 @@ const React = require("react");
 const react = require("@chakra-ui/react");
 const eastUiComponents = require("@elaraai/east-ui-components");
 const reactDom = require("react-dom");
+const internal$2 = require("@elaraai/east-ui/internal");
 const reactQuery = require("@tanstack/react-query");
 const reactVirtual = require("@tanstack/react-virtual");
 function _interopNamespaceDefault(e2) {
@@ -693,10 +694,10 @@ function clearStagedStoreSingleton() {
 }
 const UNCHANGED_VARIANT = east.variant("unchanged", null);
 const blobEqual = east.equalFor(east.BlobType);
-const eastTypeEqual = east.equalFor(internal.EastTypeType);
+const eastTypeEqual = east.equalFor(internal$1.EastTypeType);
 const helpersCache = new east.SortedMap(
   void 0,
-  east.compareFor(internal.EastTypeType)
+  east.compareFor(internal$1.EastTypeType)
 );
 function getBindingHelpers(sourceType) {
   let cached = helpersCache.get(sourceType);
@@ -1161,7 +1162,7 @@ class BindRuntime {
    *  Pass `allowed=null` for an unscoped impl (the global
    *  `BindPlatform`); pass a Set for manifest scoping. */
   buildPlatform(allowed) {
-    return e3Ui.bindPlatformFn.implement(
+    return internal.bindPlatformFn.implement(
       (sourceType) => (sourcePathArg, patchOpt, modeVariant) => {
         const sourcePath = sourcePathArg;
         const { patchPath, mode } = resolveOptions(patchOpt, modeVariant);
@@ -5263,7 +5264,7 @@ function parseManualDraft(leafType, draft) {
     return { ok: false };
   }
 }
-const diffValueEqual = east.equalFor(e3Ui.Diff.Component.schema);
+const diffValueEqual = east.equalFor(internal.Diff.Component.schema);
 function getOpt$1(opt) {
   return opt.type === "some" ? opt.value : void 0;
 }
@@ -6241,7 +6242,7 @@ const EastChakraDiff = React.memo(function EastChakraDiff2({ value }) {
 function rowKey(pathStr, leafPath) {
   return `${pathStr}::${leafPath}`;
 }
-eastUiComponents.implementUIComponent(e3Ui.Diff.Component, EastChakraDiff);
+eastUiComponents.implementUIComponent(internal.Diff.Component, EastChakraDiff);
 function cc(names) {
   if (typeof names === "string" || typeof names === "number") return "" + names;
   let out = "";
@@ -18318,7 +18319,7 @@ var hashIntsArray = function hashIntsArray2(ints, seed) {
   };
   return hashIterableInts(iterator, seed);
 };
-var hashString = function hashString2(str, seed) {
+var hashString$1 = function hashString(str, seed) {
   var entry = {
     value: 0,
     done: false
@@ -18345,9 +18346,9 @@ var hashStringsArray = function hashStringsArray2(strs) {
   for (var i = 0; i < strs.length; i++) {
     var str = strs[i];
     if (i === 0) {
-      hash2 = hashString(str);
+      hash2 = hashString$1(str);
     } else {
-      hash2 = hashString(str, hash2);
+      hash2 = hashString$1(str, hash2);
     }
   }
   return hash2;
@@ -25485,7 +25486,7 @@ var cache = function cache2(fn3, name) {
       var _p = eles[0]._private;
       var tch = _p.traversalCache = _p.traversalCache || {};
       var ch = tch[name] = tch[name] || [];
-      var hash2 = hashString(key);
+      var hash2 = hashString$1(key);
       var cacheHit = ch[hash2];
       if (cacheHit) {
         return cacheHit;
@@ -28091,13 +28092,13 @@ function styleCache(key, fn3, ele) {
   }
 }
 function cacheStyleFunction(key, fn3) {
-  key = hashString(key);
+  key = hashString$1(key);
   return function cachedStyleFunction(ele) {
     return styleCache(key, fn3, ele);
   };
 }
 function cachePrototypeStyleFunction(key, fn3) {
-  key = hashString(key);
+  key = hashString$1(key);
   var selfFn = function selfFn2(ele) {
     return fn3.call(ele);
   };
@@ -38368,7 +38369,7 @@ BRp$9.applyLabelDimensions = function(ele) {
 BRp$9.applyPrefixedLabelDimensions = function(ele, prefix2) {
   var _p = ele._private;
   var text = this.getLabelText(ele, prefix2);
-  var cacheKey = hashString(text, ele._private.labelDimsKey);
+  var cacheKey = hashString$1(text, ele._private.labelDimsKey);
   if (getPrefixedProperty(_p.rscratch, "prefixedLabelDimsKey", prefix2) === cacheKey) {
     return;
   }
@@ -42764,7 +42765,7 @@ CRp$9.drawArrowShape = function(edge, context, fill, edgeWidth, shape, shapeWidt
   var shapeImpl = r2.arrowShapes[shape];
   if (usePaths) {
     var cache3 = r2.arrowPathCache = r2.arrowPathCache || [];
-    var key = hashString(shape);
+    var key = hashString$1(shape);
     var cachedPath = cache3[key];
     if (cachedPath != null) {
       path = context = cachedPath;
@@ -53055,7 +53056,1220 @@ const EastChakraOntology = React.memo(function EastChakraOntology2({ value }) {
     }
   );
 });
-eastUiComponents.implementUIComponent(e3Ui.Ontology.Component, EastChakraOntology);
+eastUiComponents.implementUIComponent(internal.Ontology.Component, EastChakraOntology);
+const SELECTION_TYPE = east.OptionType(east.StringType);
+const encodeSelection = east.encodeBeast2For(SELECTION_TYPE);
+const decodeSelection = east.decodeBeast2For(SELECTION_TYPE);
+function deriveSelectionKey(decisions) {
+  return ["decision.selection", ...decisions.map((d2) => datasetPathToString(d2.source))].join("|");
+}
+function viewFor(binding) {
+  const workspace = getReactiveDatasetCache().getConfig().workspace ?? "";
+  const source = binding.source;
+  const types = getBindingTypes(workspace, source);
+  if (!types) {
+    throw new Error(
+      `Decision.bind: no binding registered for ${datasetPathToString(source)} — bind it with Data.bind on the same surface first`
+    );
+  }
+  const patch = binding.patch.type === "some" ? binding.patch.value : void 0;
+  return defaultBindRuntime.buildBindHandle(types.sourceType, source, patch, binding.mode.type);
+}
+const DECISION_SLICE_CONFIG = {
+  fields: /* @__PURE__ */ new Map([
+    ["kind", east.variant("string", { label: "Kind", accessor: (d2) => d2.kind })],
+    ["title", east.variant("string", { label: "Title", accessor: (d2) => d2.title })],
+    ["value", east.variant("float", { label: "Value", accessor: (d2) => d2.value })]
+  ]),
+  rangeFieldId: east.none,
+  searchFieldIds: ["kind", "title"],
+  breakdownFieldIds: []
+};
+function deriveSliceKey(decisions, sliceInit) {
+  const sources = decisions.map((d2) => datasetPathToString(d2.source));
+  const seed = sliceInit === void 0 ? "none" : hashString2(stableStringify(sliceInit));
+  return ["decision.slice", ...sources, seed].join("|");
+}
+function stableStringify(v3) {
+  return JSON.stringify(v3, (_k, x2) => {
+    if (typeof x2 === "bigint") return `${x2}n`;
+    if (x2 instanceof Date) return x2.toISOString();
+    if (x2 instanceof Set) return [...x2].sort();
+    if (x2 instanceof Map) return [...x2.entries()].sort((a2, b2) => String(a2[0]).localeCompare(String(b2[0])));
+    return x2;
+  });
+}
+function hashString2(s2) {
+  let h2 = 5381;
+  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) ?? {
+    caseId,
+    answers: /* @__PURE__ */ new Map(),
+    knowledge: east.none,
+    constraints: [],
+    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));
+      }
+    }
+  };
+  const slice3 = eastUiComponents.buildSliceHandle(
+    deriveSliceKey(decisions, sliceInit),
+    DECISION_SLICE_CONFIG,
+    sliceInit ?? eastUiComponents.DEFAULT_SLICE_STATE,
+    () => queue(),
+    east.none
+  );
+  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);
+    }
+  };
+}
+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(
+    decisionsArg,
+    judgementsArg,
+    eastUiComponents.getSomeorUndefined(sliceInitArg)
+  ))
+];
+eastUiComponents.registerPlatformImplementation(DecisionBindPlatform);
+function useHandleVersion(handle) {
+  const staged = getStagedStore();
+  const cache3 = getReactiveDatasetCache();
+  const state = eastUiComponents.StateRuntime.getStore();
+  const workspace = cache3.getConfig().workspace ?? "";
+  const keys = React.useMemo(() => {
+    if (!handle) return [];
+    const bindings = [...handle.decisions, handle.judgements];
+    const ks = [];
+    for (const b2 of bindings) {
+      ks.push(datasetCacheKey(workspace, b2.source));
+      if (b2.patch.type === "some") ks.push(datasetCacheKey(workspace, b2.patch.value));
+    }
+    return ks;
+  }, [workspace, handle]);
+  const selectionKey = handle ? deriveSelectionKey(handle.decisions) : void 0;
+  const subscribe = React.useCallback((cb) => {
+    const unsubs = keys.flatMap((k2) => [staged.subscribe(k2, cb), cache3.subscribe(k2, cb)]);
+    if (selectionKey !== void 0) unsubs.push(state.subscribe(selectionKey, cb));
+    return () => {
+      for (const u2 of unsubs) u2();
+    };
+  }, [staged, cache3, state, keys, selectionKey]);
+  const getSnapshot = React.useCallback(
+    () => keys.reduce((sum, k2) => sum + staged.getKeyVersion(k2) + cache3.getKeyVersion(k2), 0) + (selectionKey !== void 0 ? state.getKeyVersion(selectionKey) : 0),
+    [staged, cache3, state, keys, selectionKey]
+  );
+  return React.useSyncExternalStore(subscribe, getSnapshot);
+}
+function useDecisionHandle(ref) {
+  const version2 = useHandleVersion(ref);
+  const fns = React.useMemo(
+    () => ref ? buildDecisionHandle(
+      [...ref.decisions],
+      ref.judgements,
+      eastUiComponents.getSomeorUndefined(ref.slice)
+    ) : null,
+    [ref]
+  );
+  const { decisions, selected: selected2, journal } = React.useMemo(() => {
+    try {
+      if (!fns) return { decisions: null, selected: null, journal: null };
+      const sel = fns.selected();
+      return {
+        decisions: fns.queue(),
+        selected: sel.type === "some" ? sel.value : null,
+        journal: fns.journal()
+      };
+    } catch {
+      return { decisions: null, selected: null, journal: null };
+    }
+  }, [fns, version2]);
+  const judgementFor = React.useCallback((caseId) => {
+    try {
+      return fns ? fns.judgement(caseId) : null;
+    } catch {
+      return null;
+    }
+  }, [fns, version2]);
+  const commitStateFor = React.useCallback((caseId) => {
+    try {
+      return fns ? fns.commitState(caseId) : null;
+    } catch {
+      return null;
+    }
+  }, [fns, version2]);
+  const select2 = React.useCallback((caseId) => {
+    fns == null ? void 0 : fns.select(caseId);
+  }, [fns]);
+  const clearSelection = React.useCallback(() => {
+    fns == null ? void 0 : fns.clearSelection();
+  }, [fns]);
+  const update2 = React.useCallback((next2) => {
+    fns == null ? void 0 : fns.update(next2);
+  }, [fns]);
+  const answer = React.useCallback((caseId, promptId, response) => {
+    fns == null ? void 0 : fns.answer(caseId, promptId, east.variant(response, null));
+  }, [fns]);
+  const addKnowledge = React.useCallback((caseId, text) => {
+    fns == null ? void 0 : fns.addKnowledge(caseId, text);
+  }, [fns]);
+  const inject = React.useCallback((caseId, constraint) => {
+    fns == null ? void 0 : fns.inject(caseId, constraint);
+  }, [fns]);
+  const resolve2 = React.useCallback((caseId, verdict) => {
+    fns == null ? void 0 : fns.resolve(caseId, verdict);
+  }, [fns]);
+  return {
+    decisions,
+    selected: selected2,
+    journal,
+    judgementFor,
+    commitStateFor,
+    select: select2,
+    clearSelection,
+    update: update2,
+    answer,
+    addKnowledge,
+    inject,
+    resolve: resolve2,
+    slice: fns ? fns.slice : null
+  };
+}
+const OP_WORDS = {
+  eq: "=",
+  neq: "≠",
+  atMost: "at most",
+  atLeast: "at least",
+  between: "between",
+  before: "before",
+  after: "after",
+  in: "in",
+  notIn: "not in",
+  is: "is"
+};
+function formatScalar(v3) {
+  if (v3 instanceof Date) {
+    return `${v3.toLocaleString("en", { month: "short" })} ${v3.getDate()}`;
+  }
+  if (v3 instanceof Set) {
+    return `{${[...v3].map(formatScalar).join(", ")}}`;
+  }
+  if (v3 !== null && typeof v3 === "object" && !v3.type) {
+    return Object.entries(v3).map(([k2, x2]) => `${k2} ${formatScalar(x2)}`).join(" · ");
+  }
+  return String(v3);
+}
+function formatConstraint(constraint, payloadType, levers) {
+  var _a2, _b;
+  const c2 = constraint;
+  const lever = ((_a2 = levers == null ? void 0 : levers.find((l2) => l2.case === c2.type)) == null ? void 0 : _a2.label) ?? c2.type;
+  if ((payloadType == null ? void 0 : payloadType.type) === "Variant") {
+    const op = c2.value;
+    const word = OP_WORDS[op.type] ?? op.type;
+    const opType = (_b = payloadType.cases) == null ? void 0 : _b[op.type];
+    if ((opType == null ? void 0 : opType.type) === "Struct" && op.value !== null && typeof op.value === "object") {
+      const r2 = op.value;
+      if ("min" in r2 && "max" in r2) {
+        return { lever, op: word, value: `${formatScalar(r2.min)} – ${formatScalar(r2.max)}` };
+      }
+    }
+    return { lever, op: word, value: formatScalar(op.value) };
+  }
+  return { lever, op: "·", value: formatScalar(c2.value) };
+}
+const PRIMITIVES = /* @__PURE__ */ new Set(["String", "Integer", "Float", "DateTime", "Boolean"]);
+function normalizeTypeValue(tv) {
+  var _a2;
+  const n2 = tv;
+  if (n2.cases !== void 0 || n2.fields !== void 0) {
+    const out = { type: n2.type };
+    if (n2.cases) out.cases = Object.fromEntries(Object.entries(n2.cases).map(([k2, v3]) => [k2, normalizeTypeValue(v3)]));
+    if (n2.fields) out.fields = Object.fromEntries(Object.entries(n2.fields).map(([k2, v3]) => [k2, normalizeTypeValue(v3)]));
+    if (n2.key) out.key = normalizeTypeValue(n2.key);
+    if (n2.value !== void 0 && (n2.type === "Array" || n2.type === "Dict")) out.value = normalizeTypeValue(n2.value);
+    return out;
+  }
+  switch (n2.type) {
+    case "Struct":
+      return { type: "Struct", fields: Object.fromEntries(n2.value.map((f2) => [f2.name, normalizeTypeValue(f2.type)])) };
+    case "Variant":
+      return { type: "Variant", cases: Object.fromEntries(n2.value.map((f2) => [f2.name, normalizeTypeValue(f2.type)])) };
+    case "Array":
+      return { type: "Array", value: normalizeTypeValue(n2.value) };
+    case "Dict": {
+      const d2 = n2.value;
+      return { type: "Dict", key: normalizeTypeValue(d2.key), value: normalizeTypeValue(d2.value) };
+    }
+    case "Recursive": {
+      const w2 = n2.value;
+      if ((w2 == null ? void 0 : w2.type) === "wrapper" && ((_a2 = w2.value) == null ? void 0 : _a2.inner)) return normalizeTypeValue(w2.value.inner);
+      return { type: n2.type };
+    }
+    default:
+      return { type: n2.type };
+  }
+}
+function emptyFor(node2) {
+  switch (node2.type) {
+    case "Integer":
+      return 0n;
+    case "Float":
+      return 0;
+    case "DateTime":
+      return /* @__PURE__ */ new Date();
+    case "Boolean":
+      return false;
+    case "String":
+      return "";
+    case "Struct":
+      return Object.fromEntries(Object.entries(node2.fields ?? {}).map(([k2, f2]) => [k2, emptyFor(f2)]));
+    default:
+      return null;
+  }
+}
+function leverPayloadEditable(node2) {
+  if (!node2) return false;
+  if (PRIMITIVES.has(node2.type)) return true;
+  if (node2.type === "Struct") return Object.values(node2.fields ?? {}).every((f2) => PRIMITIVES.has(f2.type));
+  if (node2.type === "Variant") return Object.values(node2.cases ?? {}).every((c2) => PRIMITIVES.has(c2.type) || c2.type === "Struct" && Object.values(c2.fields ?? {}).every((f2) => PRIMITIVES.has(f2.type)));
+  return false;
+}
+const inputStyle = east.some({ size: east.some(east.variant("sm", null)) });
+function LeverEditor({ leverCase, payload, onInject }) {
+  var _a2;
+  const button = react.useRecipe({ key: "button" });
+  const isOpVariant = payload.type === "Variant";
+  const ops = React.useMemo(() => isOpVariant ? Object.keys(payload.cases ?? {}) : [], [isOpVariant, payload]);
+  const [opTag, setOpTag] = React.useState(ops[0] ?? "");
+  const active = isOpVariant ? ((_a2 = payload.cases) == null ? void 0 : _a2[opTag]) ?? { type: "Null" } : payload;
+  const valRef = React.useRef(emptyFor(active));
+  const keyRef = React.useRef(`${leverCase}:${opTag}`);
+  if (keyRef.current !== `${leverCase}:${opTag}`) {
+    keyRef.current = `${leverCase}:${opTag}`;
+    valRef.current = emptyFor(active);
+  }
+  const primitiveInput = (node2, key, get3, set3) => {
+    switch (node2.type) {
+      case "Integer":
+        return /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraIntegerInput, { value: { value: get3(), onChange: east.some(set3), style: inputStyle } }, key);
+      case "Float":
+        return /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraFloatInput, { value: { value: get3(), onChange: east.some(set3), style: inputStyle } }, key);
+      case "DateTime":
+        return /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraDateTimeInput, { value: { value: get3(), onChange: east.some(set3), style: inputStyle } }, key);
+      case "Boolean":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          eastUiComponents.EastChakraSelect,
+          {
+            ariaLabel: key,
+            value: {
+              value: east.some(String(get3())),
+              items: [{ value: "true", label: "true", disabled: east.none }, { value: "false", label: "false", disabled: east.none }],
+              placeholder: east.none,
+              multiple: east.none,
+              disabled: east.none,
+              onChange: east.some((v3) => set3(v3 === "true")),
+              onChangeMultiple: east.none,
+              onOpenChange: east.none,
+              style: inputStyle
+            }
+          },
+          key
+        );
+      default:
+        return /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.EastChakraStringInput, { value: { value: String(get3() ?? ""), onChange: east.some(set3), style: inputStyle } }, key);
+    }
+  };
+  const valueControls = React.useMemo(() => {
+    const k2 = keyRef.current;
+    if (active.type === "Struct") {
+      return Object.entries(active.fields ?? {}).map(([field, node2]) => /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "6px", minW: 0, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", textStyle: "caption.eyebrow", color: "fg.subtle", flexShrink: 0, children: field }),
+        primitiveInput(
+          node2,
+          `${k2}.${field}.in`,
+          () => valRef.current[field],
+          (v3) => {
+            valRef.current[field] = v3;
+          }
+        )
+      ] }, `${k2}.${field}`));
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(react.Box, { width: "180px", flexShrink: 0, children: primitiveInput(active, `${k2}.value`, () => valRef.current, (v3) => {
+      valRef.current = v3;
+    }) }, `${k2}.wrap`);
+  }, [active, opTag, leverCase]);
+  const submit = () => {
+    const value = valRef.current;
+    const payloadValue = active.type === "Struct" ? { ...value } : value;
+    const constraint = isOpVariant ? east.variant(leverCase, east.variant(opTag, payloadValue)) : east.variant(leverCase, payloadValue);
+    onInject(constraint);
+    valRef.current = emptyFor(active);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    react.Box,
+    {
+      display: "flex",
+      alignItems: "center",
+      gap: "8px",
+      flexWrap: "wrap",
+      minW: 0,
+      css: {
+        "& [data-scope=select][data-part=root]": { width: "auto", minWidth: "110px", flexShrink: 0 },
+        "& [data-scope=number-input][data-part=root]": { width: "150px", flexShrink: 0 }
+      },
+      children: [
+        isOpVariant && /* @__PURE__ */ jsxRuntime.jsx(
+          eastUiComponents.EastChakraSelect,
+          {
+            ariaLabel: "Operator",
+            value: {
+              value: east.some(opTag),
+              items: ops.map((o2) => ({ value: o2, label: OP_WORDS[o2] ?? o2, disabled: east.none })),
+              placeholder: east.none,
+              multiple: east.none,
+              disabled: east.none,
+              onChange: east.some((v3) => setOpTag(v3)),
+              onChangeMultiple: east.none,
+              onOpenChange: east.none,
+              style: inputStyle
+            }
+          }
+        ),
+        valueControls,
+        /* @__PURE__ */ jsxRuntime.jsx(react.chakra.button, { type: "button", css: button({ variant: "solid", size: "xs" }), onClick: submit, children: "Add" })
+      ]
+    }
+  );
+}
+function fmt(d2, n2, showSign = false) {
+  return eastUiComponents.formatTick(n2, eastUiComponents.getSomeorUndefined(d2.format), showSign);
+}
+const caption = { textStyle: "caption.eyebrow", color: "fg.muted" };
+const EvidenceFacet = React.memo(function EvidenceFacet2({ decision, children: children2 }) {
+  const stakes = eastUiComponents.getSomeorUndefined(decision.stakes);
+  const downside = eastUiComponents.getSomeorUndefined(decision.downside);
+  const confidence = eastUiComponents.getSomeorUndefined(decision.confidence);
+  const detail = eastUiComponents.getSomeorUndefined(decision.detail);
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "10px", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "baseline", gap: "12px", flexWrap: "wrap", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, color: "fg", children: "Why this is recommended" }),
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { ...caption, children: [
+        stakes !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          "stakes ",
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontWeight: "semibold", children: stakes.type }),
+          " · "
+        ] }),
+        downside !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          "if wrong ",
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontWeight: "semibold", color: "fg.danger", children: fmt(decision, downside, true) }),
+          " · "
+        ] }),
+        confidence !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          "confidence ",
+          /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { as: "span", fontFamily: "mono", fontWeight: "semibold", children: [
+            Math.round(confidence * 100),
+            "%"
+          ] })
+        ] })
+      ] })
+    ] }),
+    detail !== void 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "12.5px", color: "fg.muted", children: detail }),
+    decision.evidence.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "grid", gridTemplateColumns: "repeat(auto-fit, minmax(180px, 1fr))", gap: "8px", children: decision.evidence.map((e2, i) => {
+      const note = eastUiComponents.getSomeorUndefined(e2.note);
+      return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { borderWidth: "1px", borderColor: "border.subtle", borderRadius: "4px", px: "10px", py: "8px", bg: "bg.canvas", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, children: e2.label }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "13px", fontWeight: "medium", children: e2.text }),
+        note !== void 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "11px", fontFamily: "mono", color: "fg.subtle", children: note })
+      ] }, i);
+    }) }),
+    children2
+  ] });
+});
+function rankOptions(d2) {
+  const alternatives = [...d2.alternatives].sort((a2, b2) => b2.value - a2.value).map((a2) => ({
+    label: a2.label,
+    value: a2.value,
+    downside: eastUiComponents.getSomeorUndefined(a2.downside),
+    confidence: eastUiComponents.getSomeorUndefined(a2.confidence),
+    note: eastUiComponents.getSomeorUndefined(a2.note),
+    recommended: false
+  }));
+  return [
+    {
+      label: d2.title,
+      value: d2.value,
+      downside: eastUiComponents.getSomeorUndefined(d2.downside),
+      confidence: eastUiComponents.getSomeorUndefined(d2.confidence),
+      note: eastUiComponents.getSomeorUndefined(d2.summary),
+      recommended: true
+    },
+    ...alternatives
+  ].map((o2, i) => ({ ...o2, rank: i + 1 }));
+}
+function metaLine(o2) {
+  const parts = [];
+  if (o2.recommended) parts.push("recommended");
+  if (o2.confidence !== void 0) parts.push(`${Math.round(o2.confidence * 100)}% conf`);
+  if (!o2.recommended && o2.note !== void 0) parts.push(o2.note);
+  return parts.join(" · ");
+}
+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);
+  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 }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { height: "6px", bg: "border.subtle", borderRadius: "3px", overflow: "hidden", children: /* @__PURE__ */ jsxRuntime.jsx(react.Box, { height: "100%", width: `${Math.round(Math.min(Math.abs(frac), 1) * 100)}%`, bg: tone === "success" ? "fg.success" : tone === "danger" ? "fg.danger" : "fg.subtle", opacity: 0.7 }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "11px", fontFamily: "mono", fontWeight: "semibold", textAlign: "right", children: display })
+    ] });
+    return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "10px", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { ...caption, color: "fg", children: [
+        "Options · ",
+        options2.length,
+        " evaluated"
+      ] }),
+      options2.map((o2) => /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "4px", pl: "8px", ...o2.recommended ? { boxShadow: "inset 2px 0 0 var(--chakra-colors-accent-brand)" } : {}, children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { fontSize: "12.5px", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", color: "fg.subtle", children: o2.rank }),
+          " ",
+          /* @__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("If wrong", (o2.downside ?? 0) / maxDown, o2.downside !== void 0 ? fmt(decision, o2.downside, true) : "—", "danger")
+      ] }, o2.rank))
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "6px", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "grid", gridTemplateColumns: "minmax(180px, 1.1fr) 1fr 1fr", alignItems: "baseline", gap: "8px", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { ...caption, color: "fg", children: [
+        "Options · ",
+        options2.length,
+        " evaluated"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, textAlign: "center", children: "If wrong" }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, textAlign: "right", children: "Uplift" })
+    ] }),
+    options2.map((o2) => {
+      const downFrac = Math.min(Math.abs(o2.downside ?? 0) / maxDown, 1);
+      const upFrac = Math.min(Math.max(o2.value, 0) / maxUp, 1);
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        react.Box,
+        {
+          display: "grid",
+          gridTemplateColumns: "minmax(180px, 1.1fr) 1fr 1fr",
+          alignItems: "center",
+          gap: "8px",
+          py: "4px",
+          ...o2.recommended ? { bg: "bg.brand.subtle", boxShadow: "inset 2px 0 0 var(--chakra-colors-accent-brand)" } : {},
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { minW: 0, pl: o2.recommended ? "6px" : "0", display: "flex", alignItems: "baseline", gap: "6px", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontSize: "11px", color: "fg.subtle", flexShrink: 0, children: o2.rank }),
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontSize: "12.5px", fontWeight: o2.recommended ? "semibold" : "normal", flexShrink: 0, children: o2.label }),
+              metaLine(o2) !== "" && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontSize: "10.5px", color: "fg.muted", minW: 0, truncate: true, children: metaLine(o2) })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", justifyContent: "flex-end", alignItems: "center", gap: "6px", height: "16px", children: o2.downside !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "10.5px", fontFamily: "mono", color: "fg.danger", flexShrink: 0, children: fmt(decision, o2.downside, true) }),
+              /* @__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) })
+            ] }) })
+          ]
+        },
+        o2.rank
+      );
+    })
+  ] });
+});
+const ANSWERS = [
+  { literal: "yes", label: "Yes" },
+  { literal: "no", label: "No" },
+  { literal: "unknown", label: "Don't know" }
+];
+const JudgementFacet = React.memo(function JudgementFacet2({ decision, handle, leverPayloads }) {
+  var _a2;
+  const button = react.useRecipe({ key: "button" });
+  const input = react.useRecipe({ key: "input" });
+  const judgement = handle.judgementFor(decision.id);
+  const stagedKnowledge = (judgement == null ? void 0 : judgement.knowledge.type) === "some" ? judgement.knowledge.value : "";
+  const [knowledge, setKnowledge] = React.useState(stagedKnowledge);
+  React.useEffect(() => {
+    setKnowledge(stagedKnowledge);
+  }, [stagedKnowledge]);
+  const commitKnowledge = React.useCallback(() => {
+    if (knowledge !== stagedKnowledge) handle.addKnowledge(decision.id, knowledge);
+  }, [knowledge, stagedKnowledge, handle, decision.id]);
+  const levers = React.useMemo(
+    () => decision.levers.filter((l2) => leverPayloadEditable(leverPayloads[l2.case])),
+    [decision.levers, leverPayloads]
+  );
+  const [leverCase, setLeverCase] = React.useState(((_a2 = levers[0]) == null ? void 0 : _a2.case) ?? "");
+  const activeLever = levers.find((l2) => l2.case === leverCase) ?? levers[0];
+  const gate = handle.commitStateFor(decision.id);
+  const gateHint = (gate == null ? void 0 : gate.type) === "gated" ? gate.value === 1n ? "Answer the judgement question to enable apply" : `Answer the ${gate.value} judgement questions to enable apply` : (gate == null ? void 0 : gate.type) === "blocked" ? "Commit blocked — an answer contradicts the recommendation" : (gate == null ? void 0 : gate.type) === "handoff" ? "Awaiting handoff — an answer was don't know" : null;
+  const onInject = React.useCallback((constraint) => {
+    handle.inject(decision.id, constraint);
+  }, [handle, decision.id]);
+  if (!judgement) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "10px", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "baseline", gap: "12px", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, color: "fg.warning", children: "Required before commit" }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, marginLeft: "auto", children: "human-only signal · model can’t see this" })
+    ] }),
+    decision.prompts.map((prompt) => {
+      var _a3;
+      const current = (_a3 = judgement.answers.get(prompt.id)) == null ? void 0 : _a3.type;
+      return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "12px", flexWrap: "wrap", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "13px", fontWeight: "medium", flex: "1", minW: "180px", children: prompt.text }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", gap: "6px", flexShrink: 0, children: ANSWERS.map((a2) => /* @__PURE__ */ jsxRuntime.jsx(
+          react.chakra.button,
+          {
+            type: "button",
+            css: button({ variant: current === a2.literal ? "solid" : "outline", size: "xs" }),
+            onClick: () => handle.answer(decision.id, prompt.id, a2.literal),
+            children: a2.label
+          },
+          a2.literal
+        )) })
+      ] }, prompt.id);
+    }),
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "4px", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, children: "Knowledge · what the model can’t see" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        react.chakra.textarea,
+        {
+          css: input({ size: "sm" }),
+          rows: 2,
+          value: knowledge,
+          placeholder: "Private context — persists with the case",
+          onChange: (e2) => setKnowledge(e2.target.value),
+          onBlur: commitKnowledge
+        }
+      )
+    ] }),
+    (levers.length > 0 || judgement.constraints.length > 0) && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", flexDirection: "column", gap: "6px", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, children: "Inject constraint · next run folds it in" }),
+      judgement.constraints.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", gap: "12px", flexWrap: "wrap", children: judgement.constraints.map((c2, i) => {
+        const tag = c2.type;
+        const f2 = formatConstraint(c2, leverPayloads[tag], decision.levers);
+        return /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { as: "span", fontFamily: "mono", fontSize: "11px", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "accent.brand", fontWeight: "semibold", children: f2.lever }),
+          " ",
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.subtle", children: f2.op }),
+          " ",
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "semibold", children: f2.value })
+        ] }, i);
+      }) }),
+      activeLever !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "8px", flexWrap: "wrap", children: [
+        levers.length > 1 ? /* @__PURE__ */ jsxRuntime.jsx(react.Box, { flexShrink: 0, css: { "& [data-scope=select][data-part=root]": { width: "auto", minWidth: "160px" } }, children: /* @__PURE__ */ jsxRuntime.jsx(
+          eastUiComponents.EastChakraSelect,
+          {
+            ariaLabel: "Lever",
+            value: {
+              value: east.some(activeLever.case),
+              items: levers.map((l2) => ({ value: l2.case, label: l2.label, disabled: east.none })),
+              placeholder: east.none,
+              multiple: east.none,
+              disabled: east.none,
+              onChange: east.some((v3) => setLeverCase(v3)),
+              onChangeMultiple: east.none,
+              onOpenChange: east.none,
+              style: east.some({ size: east.some(east.variant("sm", null)) })
+            }
+          }
+        ) }) : /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, color: "fg", flexShrink: 0, children: activeLever.label }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { flex: "1", minW: "260px", children: /* @__PURE__ */ jsxRuntime.jsx(
+          LeverEditor,
+          {
+            leverCase: activeLever.case,
+            payload: leverPayloads[activeLever.case],
+            onInject
+          },
+          activeLever.case
+        ) })
+      ] })
+    ] }),
+    gateHint !== null && /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "8px", pt: "4px", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { width: "7px", height: "7px", borderRadius: "full", bg: "fg.warning", flexShrink: 0 }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { ...caption, children: gateHint }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        react.chakra.button,
+        {
+          type: "button",
+          css: button({ variant: "outline", size: "xs" }),
+          marginLeft: "auto",
+          onClick: () => handle.resolve(decision.id, east.variant("deferred", east.none)),
+          children: "Defer"
+        }
+      )
+    ] })
+  ] });
+});
+const URGENCY_RANK = {
+  overdue: 0,
+  due: 1,
+  routine: 2
+};
+const FACETS = [
+  { key: "evidence", label: "Evidence" },
+  { key: "options", label: "Options" },
+  { key: "judgement", label: "Judgement" },
+  { key: "modify", label: "Modify" }
+];
+const URGENCY_TONE = {
+  overdue: "danger",
+  due: "warning",
+  routine: "neutral"
+};
+const EXIT_MS = 560;
+const NARROW_PX = 560;
+function decisionValue(d2, n2, showSign = false) {
+  return eastUiComponents.formatTick(n2, eastUiComponents.getSomeorUndefined(d2.format), showSign);
+}
+function deadlineSuffix(d2) {
+  const deadline = eastUiComponents.getSomeorUndefined(d2.deadline);
+  if (deadline === void 0) return "";
+  if (d2.urgency.type === "overdue") {
+    const hours = Math.round((Date.now() - deadline.getTime()) / 36e5);
+    if (hours < 1) return " <1h";
+    if (hours < 48) return ` ${hours}h`;
+    return ` ${Math.round(hours / 24)}d`;
+  }
+  if (d2.urgency.type === "due") {
+    const h2 = deadline.getHours();
+    const m2 = deadline.getMinutes();
+    const meridiem = h2 >= 12 ? "pm" : "am";
+    const clock2 = h2 % 12 === 0 ? 12 : h2 % 12;
+    return m2 === 0 ? ` ${clock2}${meridiem}` : ` ${clock2}:${String(m2).padStart(2, "0")}${meridiem}`;
+  }
+  return "";
+}
+function useLeverPayloads(ref) {
+  const cache3 = getReactiveDatasetCache();
+  const workspace = cache3.getConfig().workspace ?? "";
+  return React.useMemo(() => {
+    var _a2, _b, _c;
+    if (!ref) return {};
+    const judgements = getBindingTypes(workspace, ref.judgements.source);
+    if (!(judgements == null ? void 0 : judgements.sourceType)) return {};
+    const root2 = normalizeTypeValue(judgements.sourceType);
+    const constraint = (_c = (_b = (_a2 = root2.value) == null ? void 0 : _a2.fields) == null ? void 0 : _b["constraints"]) == null ? void 0 : _c.value;
+    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 dq = react.useSlotRecipe({ key: "decisionQueue" });
+  const status = react.useSlotRecipe({ key: "status" });
+  const tabs = react.useSlotRecipe({ key: "facetTabs" });
+  const button = react.useRecipe({ key: "button" });
+  const rs = dq({});
+  const ts = tabs({});
+  const st = status({ status: URGENCY_TONE[decision.urgency.type], size: "md" });
+  const [facet, setFacet] = React.useState(defaultFacet);
+  React.useEffect(() => {
+    if (!selected2) setFacet(defaultFacet);
+  }, [selected2, defaultFacet]);
+  const gate = handle.commitStateFor(decision.id);
+  const applyEnabled = gate === null || gate.type === "ready";
+  const gatePulse = !applyEnabled && decision.prompts.length > 0;
+  const summary = eastUiComponents.getSomeorUndefined(decision.summary);
+  const handleSelect = React.useCallback(() => {
+    if (!selected2) handle.select(decision.id);
+  }, [selected2, handle, decision.id]);
+  const handleApply = React.useCallback(() => {
+    if (applyEnabled) apply2(decision);
+  }, [applyEnabled, apply2, decision]);
+  const handleReject = React.useCallback(() => {
+    reject2(decision);
+  }, [reject2, decision]);
+  const probe = React.useMemo(() => {
+    if (!selected2 || facet !== "modify" || !modify) return null;
+    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(
+    react.Box,
+    {
+      as: "button",
+      css: ts.tab,
+      ...narrow ? { flex: 1 } : {},
+      ...facet === f2.key ? { "data-on": "" } : {},
+      ...f2.key === "judgement" && gatePulse ? { "data-pulse": "" } : {},
+      "aria-pressed": facet === f2.key,
+      onClick: () => setFacet(f2.key),
+      children: f2.label
+    },
+    f2.key
+  )) });
+  const commands = /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", gap: "6px", ...narrow ? { justifyContent: "flex-end" } : {}, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.Box,
+      {
+        as: "button",
+        css: button({ variant: "solid", size: "xs" }),
+        "aria-disabled": !applyEnabled,
+        opacity: applyEnabled ? void 0 : 0.5,
+        cursor: applyEnabled ? void 0 : "not-allowed",
+        title: applyEnabled ? void 0 : "Answer the judgement to enable apply",
+        onClick: handleApply,
+        children: "Apply"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "button", css: button({ variant: "ghost", size: "xs" }), onClick: handleReject, children: "Reject" })
+  ] });
+  const title = /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { minW: 0, cursor: selected2 ? void 0 : "pointer", onClick: handleSelect, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontWeight: "semibold", children: decision.kind }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.subtle", children: " · " }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", children: decision.title }),
+    summary !== void 0 && !narrow && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.subtle", children: " · " }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.muted", children: summary })
+    ] })
+  ] });
+  const urgency = /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: st.root, flexShrink: 0, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: st.indicator }),
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: st.label, children: [
+      decision.urgency.type,
+      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) });
+  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: [
+        urgency,
+        valueText
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { mt: "2px", fontSize: "13px", children: title }),
+      selected2 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { mt: "8px", children: facetTabs }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { mt: "8px", children: commands })
+      ] })
+    ] }) : /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: rs.row, children: [
+      urgency,
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: rs.title, p: 0, children: title }),
+      valueText,
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "center", gap: "12px", children: [
+        selected2 && facetTabs,
+        commands
+      ] })
+    ] }),
+    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 === "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}` })
+    ] })
+  ] });
+});
+const RoutineGroup = React.memo(function RoutineGroup2({ routine, acceptAll, leaving, narrow }) {
+  const dq = react.useSlotRecipe({ key: "decisionQueue" });
+  const status = react.useSlotRecipe({ key: "status" });
+  const button = react.useRecipe({ key: "button" });
+  const rs = dq({});
+  const st = status({ status: "neutral", size: "md" });
+  const total = React.useMemo(() => routine.reduce((acc, d2) => acc + d2.value, 0), [routine]);
+  const format = routine[0] ? eastUiComponents.getSomeorUndefined(routine[0].format) : void 0;
+  const handleAcceptAll = React.useCallback(() => {
+    if (acceptAll) acceptAll(routine);
+  }, [acceptAll, routine]);
+  if (routine.length === 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: rs.routineGroup, children: [
+    routine.map((d2) => /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: rs.rowShell, ...leaving.has(d2.id) ? { "data-leaving": leaving.get(d2.id) } : {}, children: /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: rs.routineRow, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: st.root, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: st.indicator }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: st.label, children: "routine" })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { minW: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", children: d2.id }),
+        /* @__PURE__ */ jsxRuntime.jsxs(react.Text, { as: "span", color: "fg.muted", children: [
+          " · ",
+          d2.kind
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: rs.routineValue, children: decisionValue(d2, d2.value) })
+    ] }) }, d2.id)),
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: rs.summary, ...narrow ? { marginLeft: "0", flexWrap: "wrap" } : {}, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: rs.summaryCap, children: [
+        routine.length,
+        " routine"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.subtle", children: "·" }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontWeight: "semibold", children: eastUiComponents.formatTick(total, format) }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.muted", children: "total" }),
+      acceptAll && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "button", css: button({ variant: "solid", size: "xs" }), ml: "auto", onClick: handleAcceptAll, children: "Accept all" })
+    ] })
+  ] });
+});
+const EastChakraDecisionQueue = React.memo(function EastChakraDecisionQueue2({ value, storageKey }) {
+  var _a2;
+  const eyebrow = react.useSlotRecipe({ key: "eyebrowRow" });
+  const es = eyebrow({});
+  const handleRef = value.handle;
+  const handle = useDecisionHandle(handleRef);
+  const decisions = handle.decisions;
+  const leverPayloads = useLeverPayloads(handleRef);
+  const railAffordances = eastUiComponents.getSomeorUndefined(value.slice);
+  const sliceHandle = handle.slice;
+  eastUiComponents.useSliceReactivity(sliceHandle == null ? void 0 : sliceHandle.key);
+  const sliceState = sliceHandle !== null ? sliceHandle.read() : null;
+  const rootRef = React.useRef(null);
+  const [narrow, setNarrow] = React.useState(false);
+  React.useLayoutEffect(() => {
+    const el = rootRef.current;
+    if (!el || typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver((entries) => {
+      var _a3;
+      const width2 = ((_a3 = entries[0]) == null ? void 0 : _a3.contentRect.width) ?? 0;
+      setNarrow(width2 > 0 && width2 < NARROW_PX);
+    });
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, []);
+  const [exiting, setExiting] = React.useState(/* @__PURE__ */ new Map());
+  const prevRef = React.useRef(null);
+  const reasonsRef = React.useRef(/* @__PURE__ */ new Map());
+  const timersRef = React.useRef([]);
+  React.useLayoutEffect(() => {
+    const prev2 = prevRef.current;
+    prevRef.current = decisions;
+    if (!prev2 || !decisions) return;
+    const ids = new Set(decisions.map((d2) => d2.id));
+    const removed = prev2.filter((d2) => !ids.has(d2.id));
+    if (removed.length === 0) return;
+    setExiting((old) => {
+      const next2 = new Map(old);
+      for (const d2 of removed) {
+        next2.set(d2.id, { decision: d2, reason: reasonsRef.current.get(d2.id) ?? "removed" });
+        reasonsRef.current.delete(d2.id);
+      }
+      return next2;
+    });
+    timersRef.current.push(setTimeout(() => {
+      setExiting((old) => {
+        const next2 = new Map(old);
+        for (const d2 of removed) next2.delete(d2.id);
+        return next2;
+      });
+    }, EXIT_MS));
+  }, [decisions]);
+  React.useEffect(() => () => {
+    for (const t2 of timersRef.current) clearTimeout(t2);
+  }, []);
+  const heading = eastUiComponents.getSomeorUndefined(value.heading) ?? "Decisions waiting";
+  const onApply = React.useMemo(() => eastUiComponents.getSomeorUndefined(value.onApply), [value.onApply]);
+  const onReject = React.useMemo(() => eastUiComponents.getSomeorUndefined(value.onReject), [value.onReject]);
+  const modify = React.useMemo(
+    () => eastUiComponents.getSomeorUndefined(value.modify),
+    [value.modify]
+  );
+  const detail = React.useMemo(
+    () => eastUiComponents.getSomeorUndefined(value.detail),
+    [value.detail]
+  );
+  const defaultFacet = ((_a2 = eastUiComponents.getSomeorUndefined(value.defaultFacet)) == null ? void 0 : _a2.type) ?? "evidence";
+  const defaultExpanded = eastUiComponents.getSomeorUndefined(value.defaultExpanded);
+  const selectedId = handle.selected ?? (defaultExpanded == null ? void 0 : defaultExpanded.id) ?? null;
+  const resolve2 = React.useCallback((ds, hook2, reason) => {
+    if (hook2) for (const d2 of ds) {
+      const decision = d2;
+      queueMicrotask(() => hook2(decision));
+    }
+    for (const d2 of ds) {
+      reasonsRef.current.set(d2.id, reason);
+      handle.resolve(d2.id, reason === "reject" ? east.variant("rejected", null) : east.variant("accepted", ""));
+    }
+  }, [handle]);
+  const apply2 = React.useCallback((d2) => resolve2([d2], onApply, "apply"), [resolve2, onApply]);
+  const reject2 = React.useCallback((d2) => resolve2([d2], onReject, "reject"), [resolve2, onReject]);
+  const acceptAll = React.useCallback((ds) => resolve2(ds, onApply, "apply"), [resolve2, onApply]);
+  const { active, routine, pastSla, visible } = React.useMemo(() => {
+    const scoped = decisions ?? [];
+    const now2 = /* @__PURE__ */ new Date();
+    const live = sliceState !== null ? scoped.filter((d2) => internal$2.sliceMatches(sliceState, DECISION_SLICE_CONFIG, d2, now2)) : scoped;
+    const merged = [...live];
+    for (const { decision } of exiting.values()) {
+      if (!merged.some((d2) => d2.id === decision.id)) merged.push(decision);
+    }
+    merged.sort((a2, b2) => {
+      var _a3, _b;
+      const r2 = URGENCY_RANK[a2.urgency.type] - URGENCY_RANK[b2.urgency.type];
+      if (r2 !== 0) return r2;
+      const da = ((_a3 = eastUiComponents.getSomeorUndefined(a2.deadline)) == null ? void 0 : _a3.getTime()) ?? Infinity;
+      const db = ((_b = eastUiComponents.getSomeorUndefined(b2.deadline)) == null ? void 0 : _b.getTime()) ?? Infinity;
+      if (da !== db) return da - db;
+      return b2.value - a2.value;
+    });
+    return {
+      active: merged.filter((d2) => d2.urgency.type !== "routine"),
+      routine: merged.filter((d2) => d2.urgency.type === "routine"),
+      pastSla: merged.filter((d2) => d2.urgency.type === "overdue").length,
+      visible: live.length
+    };
+  }, [decisions, exiting, sliceState]);
+  const exitingReasons = React.useMemo(() => {
+    const m2 = /* @__PURE__ */ new Map();
+    for (const [id3, e2] of exiting) m2.set(id3, e2.reason);
+    return m2;
+  }, [exiting]);
+  if (decisions === null) {
+    return /* @__PURE__ */ jsxRuntime.jsx(react.Box, { layerStyle: "frame", p: "16px", children: /* @__PURE__ */ jsxRuntime.jsx(react.Text, { color: "fg.muted", fontSize: "13px", children: "Loading decisions…" }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { ref: rootRef, layerStyle: "frame", overflow: "hidden", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: es.root, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: es.lbl, children: heading }),
+      sliceHandle !== null && railAffordances !== void 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", alignItems: "center", minWidth: "0", flex: "1", justifyContent: "flex-end", marginRight: "10px", children: /* @__PURE__ */ jsxRuntime.jsx(
+        eastUiComponents.SliceRailCluster,
+        {
+          slice: sliceHandle,
+          affordanceKinds: railAffordances.map((a2) => a2.type)
+        }
+      ) }),
+      /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: es.meta, gap: "10px", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg", fontWeight: "semibold", children: visible }),
+          narrow ? "" : " decisions"
+        ] }),
+        pastSla > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: es.sep, children: "·" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", color: "fg.danger", fontWeight: "semibold", children: pastSla }),
+            narrow ? " SLA" : " past SLA"
+          ] })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      react.Box,
+      {
+        maxHeight: eastUiComponents.getSomeorUndefined(value.maxHeight),
+        overflowY: value.maxHeight.type === "some" ? "auto" : void 0,
+        children: [
+          active.map((d2) => /* @__PURE__ */ jsxRuntime.jsx(
+            Row,
+            {
+              decision: d2,
+              handle,
+              selected: selectedId === d2.id,
+              narrow,
+              leverPayloads,
+              modify,
+              detail,
+              defaultFacet,
+              apply: apply2,
+              reject: reject2,
+              leaving: exitingReasons.get(d2.id),
+              storageKey
+            },
+            d2.id
+          )),
+          /* @__PURE__ */ jsxRuntime.jsx(RoutineGroup, { routine, acceptAll, leaving: exitingReasons, narrow })
+        ]
+      }
+    )
+  ] });
+});
+eastUiComponents.implementUIComponent(internal.DecisionQueue.Component, EastChakraDecisionQueue);
+function verdictPresentation(verdict) {
+  switch (verdict.type) {
+    case "accepted":
+      return { tone: "success", verb: "accepted", detail: verdict.value !== "" ? verdict.value : null };
+    case "rejected":
+      return { tone: "danger", verb: "rejected", detail: null };
+    case "deferred":
+      return { tone: "neutral", verb: "deferred", detail: verdict.value.type === "some" ? verdict.value.value : null };
+    case "handoff":
+      return { tone: "warning", verb: "handed off", detail: verdict.value !== "" ? verdict.value : null };
+  }
+}
+function formatResolvedAt(j2) {
+  if (j2.resolvedAt.type !== "some") return null;
+  const d2 = j2.resolvedAt.value;
+  const month = d2.toLocaleString("en", { month: "short" });
+  const time2 = `${String(d2.getHours()).padStart(2, "0")}:${String(d2.getMinutes()).padStart(2, "0")}`;
+  return `${month} ${d2.getDate()} · ${time2}`;
+}
+const EastChakraDecisionJournal = React.memo(function EastChakraDecisionJournal2({ value }) {
+  const eyebrow = react.useSlotRecipe({ key: "eyebrowRow" });
+  const status = react.useSlotRecipe({ key: "status" });
+  const es = eyebrow({});
+  const handle = useDecisionHandle(value.handle);
+  const heading = eastUiComponents.getSomeorUndefined(value.heading) ?? "Decision journal";
+  const cache3 = getReactiveDatasetCache();
+  const workspace = cache3.getConfig().workspace ?? "";
+  const leverPayloads = React.useMemo(() => {
+    var _a2, _b, _c;
+    const judgements = getBindingTypes(workspace, value.handle.judgements.source);
+    if (!(judgements == null ? void 0 : judgements.sourceType)) return {};
+    const root2 = normalizeTypeValue(judgements.sourceType);
+    const constraint = (_c = (_b = (_a2 = root2.value) == null ? void 0 : _a2.fields) == null ? void 0 : _b["constraints"]) == null ? void 0 : _c.value;
+    return (constraint == null ? void 0 : constraint.type) === "Variant" ? constraint.cases ?? {} : {};
+  }, [workspace, value.handle]);
+  const entries = React.useMemo(() => handle.journal ?? [], [handle.journal]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { borderWidth: "1px", borderColor: "border.strong", borderRadius: "6px", background: "bg.canvas", overflow: "hidden", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { css: es.root, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: es.lbl, children: heading }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.Box, { css: es.meta, children: entries.length === 1 ? "1 entry" : `${entries.length} entries` })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.Box,
+      {
+        maxHeight: eastUiComponents.getSomeorUndefined(value.maxHeight),
+        overflowY: value.maxHeight.type === "some" ? "auto" : void 0,
+        children: entries.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(react.Text, { px: "16px", py: "14px", fontSize: "13px", color: "fg.muted", children: "No resolved cases yet — verdicts land here as the queue clears." }) : entries.map((j2, i) => {
+          const verdict = j2.verdict.type === "some" ? j2.verdict.value : null;
+          if (!verdict) return null;
+          const { tone, verb, detail } = verdictPresentation(verdict);
+          const st = status({ status: tone, size: "md" });
+          const when = formatResolvedAt(j2);
+          const knowledge = j2.knowledge.type === "some" && j2.knowledge.value !== "" ? j2.knowledge.value : null;
+          return /* @__PURE__ */ jsxRuntime.jsxs(
+            react.Box,
+            {
+              px: "16px",
+              py: "10px",
+              borderTopWidth: i === 0 ? void 0 : "1px",
+              borderColor: "border.subtle",
+              display: "flex",
+              flexDirection: "column",
+              gap: "6px",
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { display: "flex", alignItems: "baseline", gap: "10px", children: [
+                  /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { as: "span", css: st.root, flexShrink: 0, children: [
+                    /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: st.indicator }),
+                    /* @__PURE__ */ jsxRuntime.jsx(react.Box, { as: "span", css: st.label, children: verb })
+                  ] }),
+                  /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontSize: "12px", color: "fg.muted", children: j2.caseId }),
+                  detail !== null && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontSize: "13px", minW: 0, flex: "1", truncate: true, children: detail }),
+                  when !== null && /* @__PURE__ */ jsxRuntime.jsx(react.Text, { as: "span", fontFamily: "mono", fontSize: "11.5px", color: "fg.muted", marginLeft: "auto", flexShrink: 0, children: when })
+                ] }),
+                knowledge !== null && /* @__PURE__ */ jsxRuntime.jsxs(
+                  react.Text,
+                  {
+                    fontSize: "12.5px",
+                    fontStyle: "italic",
+                    color: "fg.muted",
+                    borderLeftWidth: "2px",
+                    borderColor: "border.strong",
+                    paddingLeft: "10px",
+                    children: [
+                      "“",
+                      knowledge,
+                      "”"
+                    ]
+                  }
+                ),
+                j2.constraints.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(react.Box, { display: "flex", gap: "12px", flexWrap: "wrap", children: j2.constraints.map((c2, k2) => {
+                  const tag = c2.type;
+                  const f2 = formatConstraint(c2, leverPayloads[tag]);
+                  return /* @__PURE__ */ jsxRuntime.jsx(eastUiComponents.ClauseChip, { field: f2.lever, op: f2.op, value: f2.value }, k2);
+                }) })
+              ]
+            },
+            j2.caseId
+          );
+        })
+      }
+    )
+  ] });
+});
+eastUiComponents.implementUIComponent(internal.DecisionJournal.Component, EastChakraDecisionJournal);
 function formatApiError(error3) {
   if (error3 instanceof e3ApiClient.ApiError && error3.details != null) {
     const details = error3.details;
@@ -53981,7 +55195,7 @@ const UITaskPreview = React.memo(function UITaskPreview2({
   const manifest = React.useMemo(() => {
     if (!details || !isUI) return null;
     const meta3 = getTaskMetadata(details);
-    return meta3 ? e3Ui.decodeManifest(meta3) : { paths: [] };
+    return meta3 ? internal.decodeManifest(meta3) : { paths: [] };
   }, [details, isUI]);
   const outputPath = details ? treePathToString$1(details.output) : null;
   const preloads = React.useMemo(
@@ -54569,6 +55783,8 @@ exports.BindRuntime = BindRuntime;
 exports.DataTaskPreview = DataTaskPreview;
 exports.DatasetPreview = DatasetPreview;
 exports.E3Provider = E3Provider;
+exports.EastChakraDecisionJournal = EastChakraDecisionJournal;
+exports.EastChakraDecisionQueue = EastChakraDecisionQueue;
 exports.EastChakraDiff = EastChakraDiff;
 exports.EastChakraOntology = EastChakraOntology;
 exports.EastValueViewer = EastValueViewer;
@@ -54628,6 +55844,7 @@ exports.useDatasetListWithStatus = useDatasetListWithStatus;
 exports.useDatasetSet = useDatasetSet;
 exports.useDatasetStatus = useDatasetStatus;
 exports.useDatasetValue = useDatasetValue;
+exports.useDecisionHandle = useDecisionHandle;
 exports.useE3Config = useE3Config;
 exports.useE3ConfigOptional = useE3ConfigOptional;
 exports.usePackageExport = usePackageExport;