@promptctl/cc-candybar 1.37.0 → 1.39.0

package/src/render/action.ts

@@ -25,10 +25,16 @@ import type { FuncMap, Template } from "@promptctl/go-template-js";
 import type { VariableStore } from "../var-system/store.js";
 import { toString as varToString } from "../var-system/types.js";
 import { buildScope } from "../template-engine/scope.js";
-import type { ActionDecl } from "../config/action.js";
+import {
+  actionDestinations,
+  actionIsDual,
+  PERSIST_WHEN,
+  type ActionDecl,
+} from "../config/action.js";
 import { resolveOptionDomain } from "../config/option-domain.js";
+import { pickCycleDisplay } from "../config/disclosure.js";
 import { encodeLayoutOp, type LayoutOp } from "../config/layout-ops.js";
-import type { StripStyle } from "../themes/policy.js";
+import { parseSessionBoolean, type StripStyle } from "../themes/policy.js";
 import {
   effectsUrl,
   VERB_APPLY_LAYOUT_OP,
@@ -166,7 +172,24 @@ export type CompiledActionDecl =
   // there is nothing to carry, since the history stack (not this action) is
   // what decides which entry moves.
   | { readonly kind: "undo" }
-  | { readonly kind: "redo" };
+  | { readonly kind: "redo" }
+  // [LAW:dataflow-not-control-flow] candybar-settings-ui-aok.3's ONE control
+  // per setting. Both destinations are compiled here as the ordinary
+  // single-destination shapes they are, and `selector` names the session key
+  // whose boolean value picks between them at click time. The destination is
+  // therefore a VALUE flowing through `activeDestination` — every consumer
+  // (realize, the picker, selectDisplay) resolves it once at the top and then
+  // runs the code it has always run, so nothing downstream branches on
+  // "is this dual".
+  | {
+      readonly kind: "dual";
+      readonly selector: string;
+      readonly session: CompiledActionDecl;
+      readonly durable: CompiledActionDecl;
+      // The SessionState key the session half writes, carried so a durable
+      // click can clear it in the same dispatch (see realize's dual arm).
+      readonly sessionKey: string;
+    };
 
 export type CompiledActions = ReadonlyMap<string, CompiledActionDecl>;
 
@@ -185,6 +208,13 @@ export type CompiledActions = ReadonlyMap<string, CompiledActionDecl>;
 // highlight is inert (readVar falls back to "" since no such var exists).
 const CONFIG_KEY_TO_EFFECTIVE_VAR: ReadonlyMap<string, string> = new Map([
   ["palette", "theme.effective"],
+  // [LAW:one-source-of-truth] `preset` earns its entry here the moment a DUAL
+  // control writes it: compileDual makes BOTH halves read back through this
+  // map, so a field missing from it loses its current-selection mark on the
+  // session side too — and the preset picker sits on the settings menu's
+  // always-visible first row, where "which arrangement am I in" is the whole
+  // question the control answers.
+  ["preset", "preset.effective"],
   ["look", "look.effective"],
   ["style", "style.effective"],
   ["charset", "charset.effective"],
@@ -263,6 +293,20 @@ function compileAction(
   stateKeyToVar: ReadonlyMap<string, string>,
   perConfigDomains: ReadonlyMap<string, readonly string[]>,
 ): CompiledActionDecl {
+  // [LAW:one-source-of-truth] A dual compiles as its own two destinations —
+  // the SAME explosion the validator derivations fold over
+  // (actionDestinations), so the click a dual realizes and the gate it derives
+  // come from one statement of what the two halves are. It is matched BEFORE
+  // the `set` arm because a dual carries `set` too.
+  if (actionIsDual(action)) {
+    const [session, durable] = actionDestinations(action);
+    return compileDual(
+      stateKeyToVar.get(action[PERSIST_WHEN]) ?? action[PERSIST_WHEN],
+      action.set,
+      compileAction(parse, name, session!, stateKeyToVar, perConfigDomains),
+      compileAction(parse, name, durable!, stateKeyToVar, perConfigDomains),
+    );
+  }
   if ("set" in action) {
     const stateVar = stateKeyToVar.get(action.set) ?? action.set;
     if ("to" in action) {
@@ -379,6 +423,55 @@ function compileAction(
   return "undo" in action ? { kind: "undo" } : { kind: "redo" };
 }
 
+// [LAW:one-source-of-truth] A dual control shows ONE current value and writes
+// relative to the value it showed — so both destinations read back through the
+// DURABLE half's variable, which is the `.effective` projection the daemon
+// resolved for this render (CONFIG_KEY_TO_EFFECTIVE_VAR above): the value the
+// bar is actually rendering with, whatever chain produced it. Reading the
+// session key instead would let a cycle's glyph name the effective state while
+// its click stepped from an unwritten session key — the toggle would render
+// "wrap: off" and write "false", a click that visibly does nothing. Arms that
+// carry no `stateVar` (the bounded steppers) read nothing at render by design:
+// their step is relative and resolved daemon-side.
+function compileDual(
+  selectorVar: string,
+  sessionKey: string,
+  session: CompiledActionDecl,
+  durable: CompiledActionDecl,
+): CompiledActionDecl {
+  const readBack =
+    "stateVar" in session && "stateVar" in durable
+      ? { ...session, stateVar: durable.stateVar }
+      : session;
+  return {
+    kind: "dual",
+    selector: selectorVar,
+    session: readBack,
+    durable,
+    sessionKey,
+  };
+}
+
+// [LAW:dataflow-not-control-flow] THE destination fold: which store a dual
+// action writes is the boolean value of its selector key, read from the same
+// live store the rest of the render reads. Total over every compiled action —
+// a single-destination action IS its own destination — so callers resolve
+// through it unconditionally and never test for the dual kind.
+//
+// [LAW:one-source-of-truth] `parseSessionBoolean` is the one spelling of a
+// boolean in SessionState (themes/policy.ts), the same parse `autoWrap`'s own
+// session half goes through: an unwritten, malformed, or "false" selector all
+// mean the session destination, and only a canonical "true" means durable.
+export function activeDestination(
+  c: CompiledActionDecl,
+  store: VariableStore,
+): CompiledActionDecl {
+  if (c.kind !== "dual") return c;
+  return parseSessionBoolean(readVar(store, c.selector)) === true
+    ? c.durable
+    : c.session;
+}
+
 function parseActionTemplate(
   parse: (src: string) => Template<RichText>,
   src: string,
@@ -463,18 +556,18 @@ function cycleIndex(
 // cell of an option picker, is pure waste). set-* arms read individual vars
 // directly. This is data locality, not a control-flow guard: the scope simply
 // flows into the arms that need it.
-function realize(
+export function realize(
   c: CompiledActionDecl,
   display: string,
   boundValue: string | undefined,
   store: VariableStore,
   sessionId: string,
-): { effect: Effect; active: boolean } {
+): { effects: readonly Effect[]; active: boolean } {
   switch (c.kind) {
     case "set-literal": {
       const current = readVar(store, c.stateVar);
       return {
-        effect: { verb: VERB_SET_STATE, args: [sessionId, c.key, c.value] },
+        effects: [{ verb: VERB_SET_STATE, args: [sessionId, c.key, c.value] }],
         active: current === c.value,
       };
     }
@@ -482,7 +575,7 @@ function realize(
       const value = boundValue ?? display;
       const current = readVar(store, c.stateVar);
       return {
-        effect: { verb: VERB_SET_STATE, args: [sessionId, c.key, value] },
+        effects: [{ verb: VERB_SET_STATE, args: [sessionId, c.key, value] }],
         active: current === value,
       };
     }
@@ -499,7 +592,7 @@ function realize(
       const value = boundValue ?? display;
       const current = readVar(store, c.stateVar);
       return {
-        effect: { verb: VERB_SET_STATE, args: [sessionId, c.key, value] },
+        effects: [{ verb: VERB_SET_STATE, args: [sessionId, c.key, value] }],
         active: current === value,
       };
     }
@@ -510,7 +603,7 @@ function realize(
       // promised.
       const next = c.members[(cycleIndex(c, store) + 1) % c.members.length]!;
       return {
-        effect: { verb: VERB_SET_STATE, args: [sessionId, c.key, next] },
+        effects: [{ verb: VERB_SET_STATE, args: [sessionId, c.key, next] }],
         active: false,
       };
     }
@@ -522,27 +615,33 @@ function realize(
       // single range gate. So the link is byte-identical across renders and N
       // rapid clicks each accumulate (the idempotent absolute-write bug is gone).
       return {
-        effect: {
-          verb: VERB_STEP_STATE,
-          args: [sessionId, c.key, String(c.by)],
-        },
+        effects: [
+          {
+            verb: VERB_STEP_STATE,
+            args: [sessionId, c.key, String(c.by)],
+          },
+        ],
         active: false,
       };
     }
     case "copy":
       return {
-        effect: {
-          verb: VERB_COPY,
-          args: [evalTemplate(c.text, buildScope(store))],
-        },
+        effects: [
+          {
+            verb: VERB_COPY,
+            args: [evalTemplate(c.text, buildScope(store))],
+          },
+        ],
         active: false,
       };
     case "open":
       return {
-        effect: {
-          verb: VERB_OPEN_VSCODE,
-          args: [evalTemplate(c.target, buildScope(store))],
-        },
+        effects: [
+          {
+            verb: VERB_OPEN_VSCODE,
+            args: [evalTemplate(c.target, buildScope(store))],
+          },
+        ],
         active: false,
       };
     // [LAW:one-source-of-truth] The persist-* arms mirror set-*'s realization
@@ -553,7 +652,7 @@ function realize(
     case "persist-literal": {
       const current = readVar(store, c.stateVar);
       return {
-        effect: { verb: VERB_SET_CONFIG, args: [sessionId, c.key, c.value] },
+        effects: [{ verb: VERB_SET_CONFIG, args: [sessionId, c.key, c.value] }],
         active: current === c.value,
       };
     }
@@ -561,29 +660,31 @@ function realize(
       const value = boundValue ?? display;
       const current = readVar(store, c.stateVar);
       return {
-        effect: { verb: VERB_SET_CONFIG, args: [sessionId, c.key, value] },
+        effects: [{ verb: VERB_SET_CONFIG, args: [sessionId, c.key, value] }],
         active: current === value,
       };
     }
     case "persist-cycle": {
       const next = c.members[(cycleIndex(c, store) + 1) % c.members.length]!;
       return {
-        effect: { verb: VERB_SET_CONFIG, args: [sessionId, c.key, next] },
+        effects: [{ verb: VERB_SET_CONFIG, args: [sessionId, c.key, next] }],
         active: false,
       };
     }
     case "persist-bounded": {
       return {
-        effect: {
-          verb: VERB_STEP_CONFIG,
-          args: [sessionId, c.key, String(c.by)],
-        },
+        effects: [
+          {
+            verb: VERB_STEP_CONFIG,
+            args: [sessionId, c.key, String(c.by)],
+          },
+        ],
         active: false,
       };
     }
     case "reset":
       return {
-        effect: { verb: VERB_RESET_CONFIG, args: [sessionId, c.key] },
+        effects: [{ verb: VERB_RESET_CONFIG, args: [sessionId, c.key] }],
         active: false,
       };
     // [LAW:one-source-of-truth] No key to carry — the click just says "step
@@ -592,12 +693,12 @@ function realize(
     // a history step is a one-shot trigger, not a current-selection toggle.
     case "undo":
       return {
-        effect: { verb: VERB_UNDO, args: [sessionId] },
+        effects: [{ verb: VERB_UNDO, args: [sessionId] }],
         active: false,
       };
     case "redo":
       return {
-        effect: { verb: VERB_REDO, args: [sessionId] },
+        effects: [{ verb: VERB_REDO, args: [sessionId] }],
         active: false,
       };
     // [LAW:one-source-of-truth] The op is fixed at compile time (see
@@ -608,10 +709,12 @@ function realize(
     // trigger, not a current-selection toggle.
     case "layout-op":
       return {
-        effect: {
-          verb: VERB_APPLY_LAYOUT_OP,
-          args: [sessionId, c.key, encodeLayoutOp(c.op)],
-        },
+        effects: [
+          {
+            verb: VERB_APPLY_LAYOUT_OP,
+            args: [sessionId, c.key, encodeLayoutOp(c.op)],
+          },
+        ],
         active: false,
       };
     // [LAW:one-source-of-truth] The picked option (boundValue ?? display — the
@@ -620,6 +723,46 @@ function realize(
     // emits, so the daemon's apply-layout-op handler and undo/redo need no
     // knowledge of where the segment name came from. Never "active": a
     // structural edit is a one-shot trigger, not a current-selection toggle.
+    // [LAW:dataflow-not-control-flow] The destination is resolved to a value
+    // and the SAME fold runs on it — a dual's realization is its chosen
+    // half's realization, with nothing about persistence duplicated here.
+    // Depth is structurally one: a dual's halves are the single-destination
+    // decls actionDestinations built, which can never be dual themselves.
+    //
+    // [LAW:no-silent-failure] A DURABLE click carries the session key to
+    // RELEASE as a trailing arg on its own write, so the daemon drops it only
+    // after that write succeeded. Without the release the write would be
+    // invisible to the session that made it — every settable global resolves
+    // session pick OVER durable default, so the workflow this menu invites
+    // ("try it here, then tick persist? to commit it") would set a default the
+    // user cannot see and leave the control dead for the rest of the session.
+    // Riding the write rather than sitting beside it is what makes the pair
+    // unsplittable: a click runs every effect it carries, so a rejected write
+    // must not be able to drop the pick on its own.
+    case "dual": {
+      const chosen = activeDestination(c, store);
+      const { effects, active } = realize(
+        chosen,
+        display,
+        boundValue,
+        store,
+        sessionId,
+      );
+      // The durable write carries the session key to RELEASE as one more
+      // segment on itself, so the daemon clears it only after its own write
+      // succeeded. A second effect beside it would not do: `dispatch` runs
+      // every effect in a click by design, so a rejected write would still
+      // wipe the session pick and leave nothing durable in its place.
+      return chosen === c.durable
+        ? {
+            effects: effects.map((e) => ({
+              ...e,
+              args: [...e.args, c.sessionKey],
+            })),
+            active,
+          }
+        : { effects, active };
+    }
     case "layout-op-option": {
       const segment = boundValue ?? display;
       const op: LayoutOp = {
@@ -629,10 +772,12 @@ function realize(
         relation: c.relation,
       };
       return {
-        effect: {
-          verb: VERB_APPLY_LAYOUT_OP,
-          args: [sessionId, c.key, encodeLayoutOp(op)],
-        },
+        effects: [
+          {
+            verb: VERB_APPLY_LAYOUT_OP,
+            args: [sessionId, c.key, encodeLayoutOp(op)],
+          },
+        ],
         active: false,
       };
     }
@@ -656,15 +801,16 @@ function selectDisplay(
     throw new Error(`action "${name}" needs a display (the clickable text)`);
   }
   if (action.kind === "set-cycle" || action.kind === "persist-cycle") {
-    if (displays.length !== 1 && displays.length !== action.members.length) {
-      throw new Error(
-        `action "${name}" cycles ${action.members.length} members; bind one display per member (${action.members.length}) or one static display, got ${displays.length}`,
-      );
-    }
-    const display =
-      displays.length === 1
-        ? displays[0]!
-        : displays[cycleIndex(action, store)]!;
+    // [LAW:single-enforcer] The arity rule and the pick are the disclosure
+    // primitive's, not this file's — `{{ menu }}` resolves its own trigger
+    // through the same function over its `[closed, member]` cycle, so the two
+    // disclosure kinds cannot disagree about what a display binding means.
+    const display = pickCycleDisplay(
+      `action "${name}"`,
+      displays,
+      action.members.length,
+      cycleIndex(action, store),
+    );
     return { display, boundValue: undefined };
   }
   if (displays.length > 2) {
@@ -682,24 +828,34 @@ export function renderAction(
   displays: readonly string[],
   runtime: ActionRuntime,
 ): RichText {
-  const action = runtime.compiled.get(name);
+  const declared = runtime.compiled.get(name);
   // [LAW:no-defensive-null-guards] The loader validates every `{{ action "x" }}`
   // reference resolves to a declared action, and compileActions compiled every
   // declared action for THIS config's engine. A miss is a caller/wiring bug.
-  if (!action) {
+  if (!declared) {
     throw new Error(`action "${name}" is not declared in this config`);
   }
   const store = runtime.store;
-  const { display, boundValue } = selectDisplay(name, action, displays, store);
+  // [LAW:dataflow-not-control-flow] DISPLAY selection reads the resolved half
+  // (a cycle's glyph is the current member's, whichever store it will write),
+  // while REALIZATION is handed the declaration itself — a dual realizes as
+  // its chosen half PLUS the session clear that keeps a durable write visible,
+  // and that pairing belongs to the one fold that owns the union.
+  const { display, boundValue } = selectDisplay(
+    name,
+    activeDestination(declared, store),
+    displays,
+    store,
+  );
   const sessionId = readVar(store, "session.id");
-  const { effect, active } = realize(
-    action,
+  const { effects, active } = realize(
+    declared,
     display,
     boundValue,
     store,
     sessionId,
   );
-  return linkFragment(display, effectsUrl([effect]), active);
+  return linkFragment(display, effectsUrl(effects), active);
 }
 
 // ─── FuncMap entry ─────────────────────────────────────────────────────────────

package/src/render/menu.ts

@@ -1,11 +1,22 @@
 // [LAW:locality-or-seam] The runtime half of the `{{ menu }}` seam — sibling to
 // `{{ action }}`/`{{ picker }}`. A menu is a self-contained disclosure: an inline
-// glyph that toggles open/closed, and (when open) its body — a picker grid —
+// TRIGGER that toggles open/closed, and (when open) its body — a picker grid —
 // that DROPS onto the line(s) below the enclosing row. The body is the one picker
-// renderer (`renderPicker`); the glyph is a coupled set-state the menu composes
+// renderer (`renderPicker`); the trigger is a coupled set-state the menu composes
 // directly (like the picker's closeOnPick) — it toggles the open-state AND resets
 // the page cursor in one atomic batch, gated by the synthesized cycle action.
 //
+// [LAW:one-source-of-truth] The trigger's TEXT is authored, never emitted here.
+// This module used to append ▸/▾ from the glyph constants, while the codebase's
+// other disclosure — group sugar — spliced those same constants into the
+// template it synthesized, where an author could see and change them. Two
+// policies for one fact; the docs sided with the visible one ("the trigger is
+// any template content you like") while a menu appended a glyph nobody wrote,
+// which is why edit mode's `+` rendered `+▸`. A menu's disclosure IS a
+// two-member cycle, so its trigger now binds displays exactly as a cycle
+// `{{ action }}` does, through the same `pickCycleDisplay` (candybar-settings-
+// ui-aok.4).
+//
 // [LAW:effects-at-boundaries] The helper is a PURE function of its inputs (the
 // walk-published placement + the live store): it computes the inline glyph and,
 // when open, the body, and RETURNS them together — the glyph as the fragment, the
@@ -42,11 +53,7 @@ import {
   parseMenuOptions,
   type MenuOptions,
 } from "../config/menu-keys.js";
-import {
-  DISCLOSURE_CLOSED,
-  DISCLOSURE_GLYPH_CLOSED,
-  DISCLOSURE_GLYPH_OPEN,
-} from "../config/disclosure.js";
+import { DISCLOSURE_CLOSED, pickCycleDisplay } from "../config/disclosure.js";
 import { effectsUrl, VERB_SET_STATE } from "../click/wire.js";
 import { linkFragment, readVar, type ActionRuntime } from "./action.js";
 import { renderPicker } from "./picker.js";
@@ -94,9 +101,10 @@ export function collectMenuDrops(
 }
 
 // Realize a `{{ menu }}` against the live placement + state: return its inline
-// glyph, carrying the (open) body as out-of-band metadata for the boundary.
+// trigger, carrying the (open) body as out-of-band metadata for the boundary.
 function renderMenu(
   applyName: string,
+  displays: readonly string[],
   options: MenuOptions,
   runtime: MenuRuntime,
 ): RichText {
@@ -139,8 +147,14 @@ function renderMenu(
   // coupled batch passes the same wire gate every click does [LAW:single-enforcer].
   const sessionId = readVar(action.store, "session.id");
   const successor = open ? DISCLOSURE_CLOSED : member;
+  // [LAW:one-source-of-truth] The trigger's text is AUTHORED, resolved through
+  // the one display rule a cycle `{{ action }}` uses — a menu's disclosure is a
+  // two-member cycle, so binding `"▸" "▾"` gives the per-state form and binding
+  // `"+"` gives the static one. Nothing is appended here: a disclosure glyph an
+  // author never wrote is a glyph they cannot decline, which is exactly how
+  // edit mode's `+` came to read `+▸`.
   const glyph = linkFragment(
-    open ? DISCLOSURE_GLYPH_OPEN : DISCLOSURE_GLYPH_CLOSED,
+    pickCycleDisplay(`{{ menu "${applyName}" }}`, displays, 2, open ? 1 : 0),
     effectsUrl([
       {
         verb: VERB_SET_STATE,
@@ -178,25 +192,65 @@ function renderMenu(
   return glyph;
 }
 
+// [LAW:parse-dont-validate] THE crossing for a `{{ menu }}`'s argument tail.
+// The engine cannot type these slots for us — displays are strings and the
+// optional trailing knobs are a dict, so one declared slot type would refuse
+// one of them — so the tail arrives as opaque values and leaves here as a
+// record whose shape the renderer can no longer doubt: displays are strings,
+// options are parsed. Every rejected shape names the legal one.
+interface MenuArgs {
+  readonly displays: readonly string[];
+  readonly options: MenuOptions;
+}
+// [LAW:one-source-of-truth] This splits the tail on VALUES; the loader splits
+// the same tail on EXPRS (`menu-synth.ts`). They agree because the loader admits
+// only call sites where they provably must: a last argument that is neither a
+// string literal nor a literal `(dict …)` is a load error whenever both readings
+// would be legal, so what reaches here can only match the loader's reading or
+// throw below.
+const isDict = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null && !Array.isArray(v);
+
+function parseMenuArgs(applyName: string, tail: readonly unknown[]): MenuArgs {
+  // The dict is the LAST argument when present; everything before it is a
+  // display. One position, so a reader never has to count.
+  const last = tail[tail.length - 1];
+  const optsArg = isDict(last) ? last : undefined;
+  const displayArgs = optsArg === undefined ? tail : tail.slice(0, -1);
+  const bad = displayArgs.findIndex((d) => typeof d !== "string");
+  if (bad !== -1) {
+    throw new Error(
+      `{{ menu "${applyName}" }} display #${bad + 1} is not text (${JSON.stringify(displayArgs[bad])}) — a menu binds its trigger text, then an optional trailing (dict …) of options`,
+    );
+  }
+  return {
+    displays: displayArgs as readonly string[],
+    // [LAW:one-source-of-truth] The same option reader the loader folds over
+    // the static dict — vocabulary, types, defaults live once.
+    options: parseMenuOptions(optsArg ?? {}),
+  };
+}
+
 // [LAW:dataflow-not-control-flow] One func; the apply-action NAME is the menu's
-// whole identity (the page cursor is derived from it, not passed), and the rare
-// knobs travel as ONE optional trailing `(dict …)` — closeOnPick (default
-// false: stay-open), paged (default true: a drop menu wants bounded height),
-// key (accordion grouping: omitted ⇒ independent, present ⇒ mutually exclusive
-// with siblings sharing it). Values, not modes. The loader gates the same dict
-// statically (staticDictEntries), so an old positional tail never reaches this
-// fn — it is a migration-pointing load error.
+// whole identity (the page cursor is derived from it, not passed), the TRIGGER
+// TEXT is bound like a cycle action's display (one per state, or one static),
+// and the rare knobs travel as ONE optional trailing `(dict …)` — closeOnPick
+// (default false: stay-open), paged (default true: a drop menu wants bounded
+// height), key (accordion grouping: omitted ⇒ independent, present ⇒ mutually
+// exclusive with siblings sharing it). Values, not modes. The loader gates the
+// same dict statically (staticDictEntries), so an old positional tail never
+// reaches this fn — it is a migration-pointing load error.
 //
 // [LAW:one-way-deps] Injected into the engine by registerDslConfig as data; the
 // generic engine never imports this module.
 export function menuFuncs(runtime: MenuRuntime): FuncMap {
   return {
     menu: {
-      fn: (applyName: string, opts?: Record<string, unknown>) =>
-        // [LAW:one-source-of-truth] The same option reader the loader folds
-        // over the static dict — vocabulary, types, defaults live once.
-        renderMenu(applyName, parseMenuOptions(opts ?? {}), runtime),
-      argTypes: ["string", "dict"],
+      fn: (applyName: string, ...tail: unknown[]) => {
+        const { displays, options } = parseMenuArgs(applyName, tail);
+        return renderMenu(applyName, displays, options, runtime);
+      },
+      argTypes: ["string", "value"],
       returnType: "T",
     },
   };