@promptctl/cc-candybar 1.37.0 → 1.39.0

package/src/render/picker.ts

@@ -28,21 +28,17 @@ import type { FuncMap } from "@promptctl/go-template-js";
 import { toNumber } from "../var-system/types.js";
 import { stripChromeCols } from "./strip.js";
 import { TERM_COLS_VAR } from "../config/dsl-types.js";
+import { effectsUrl, VERB_SET_STATE } from "../click/wire.js";
 import {
-  effectsUrl,
-  VERB_APPLY_LAYOUT_OP,
-  VERB_SET_CONFIG,
-  VERB_SET_STATE,
-} from "../click/wire.js";
-import { encodeLayoutOp } from "../config/layout-ops.js";
-import {
+  activeDestination,
   linkFragment,
+  realize,
   readVar,
   type ActionRuntime,
   type CompiledActionDecl,
 } from "./action.js";
+import { DISCLOSURE_GLYPH_CLOSE } from "../config/disclosure.js";
 
-const PICKER_CLOSE = "✕";
 const PICKER_PREV = "←";
 const PICKER_NEXT = "→";
 
@@ -160,7 +156,15 @@ function requireOptionKind(
   CompiledActionDecl,
   { kind: "set-option" | "persist-option" | "layout-op-option" }
 > {
-  const action = runtime.compiled.get(name);
+  // [LAW:dataflow-not-control-flow] A dual-destination action resolves to the
+  // half its selector names BEFORE the kind check, so a picker over a dual is
+  // a picker over whichever option kind is live — the grid, its current-mark,
+  // and its close folding are the code they already were. The check below then
+  // still names a real, single-destination kind in its error.
+  const declared = runtime.compiled.get(name);
+  const action = declared
+    ? activeDestination(declared, runtime.store)
+    : declared;
   if (
     !action ||
     (action.kind !== "set-option" &&
@@ -194,6 +198,13 @@ export function renderPicker(
   runtime: ActionRuntime,
 ): RichText {
   const apply = requireOptionKind(runtime, applyName);
+  // [LAW:one-source-of-truth] The GRID reads the resolved half above (its
+  // options, its current-mark); the CLICK is realized from the declaration
+  // itself, through the same fold `{{ action }}` uses. That is what carries a
+  // dual's session clear into a picked option — the picker never learns what a
+  // dual is, and there is no second projection of "what does this option
+  // write" to drift from realize's.
+  const declared = runtime.compiled.get(applyName)!;
   const store = runtime.store;
   const sessionId = readVar(store, "session.id");
   // [LAW:no-defensive-null-guards] layout-op-option carries no `stateVar` —
@@ -231,7 +242,7 @@ export function renderPicker(
           2 * runtime.padding,
       )
     : Infinity;
-  const closeReserve = cellWidth(PICKER_CLOSE) + 1;
+  const closeReserve = cellWidth(DISCLOSURE_GLYPH_CLOSE) + 1;
   const arrowReserve = cellWidth(PICKER_PREV) + 1 + cellWidth(PICKER_NEXT) + 1;
   const firstPass = paginate(widths, available, closeReserve);
   const pages =
@@ -275,33 +286,26 @@ export function renderPicker(
     ? [{ verb: VERB_SET_STATE, args: [sessionId, ...closeFlat] }]
     : [];
   const optionUrl = (option: string): string => {
-    if (apply.kind === "persist-option") {
-      return effectsUrl([
-        { verb: VERB_SET_CONFIG, args: [sessionId, apply.key, option] },
-        ...closeEffect,
-      ]);
-    }
-    if (apply.kind === "layout-op-option") {
-      const op = encodeLayoutOp({
-        op: "insert",
-        segment: option,
-        anchor: apply.anchor,
-        relation: apply.relation,
-      });
-      return effectsUrl([
-        { verb: VERB_APPLY_LAYOUT_OP, args: [sessionId, apply.key, op] },
-        ...closeEffect,
-      ]);
-    }
-    return effectsUrl([
-      {
-        verb: VERB_SET_STATE,
-        args: [sessionId, apply.key, option, ...(closeOnPick ? closeFlat : [])],
-      },
-    ]);
+    const { effects } = realize(declared, option, option, store, sessionId);
+    // [LAW:one-source-of-truth] A plain session pick folds its close pairs into
+    // the SAME set-state (setState is variadic), so closing and applying are
+    // one write. Every other shape — a durable write, a structural op, a dual
+    // carrying its session clear — takes more than one effect already, so its
+    // close rides as its own effect in the same atomic dispatch.
+    const solo = effects.length === 1 ? effects[0]! : undefined;
+    return solo?.verb === VERB_SET_STATE
+      ? effectsUrl([
+          {
+            verb: VERB_SET_STATE,
+            args: [...solo.args, ...(closeOnPick ? closeFlat : [])],
+          },
+        ])
+      : effectsUrl([...effects, ...closeEffect]);
   };
 
-  const frags: RichText[] = [linkFragment(PICKER_CLOSE, closeUrl, false)];
+  const frags: RichText[] = [
+    linkFragment(DISCLOSURE_GLYPH_CLOSE, closeUrl, false),
+  ];
   if (pageIdx > 0) {
     frags.push(linkFragment(PICKER_PREV, pageUrl(pageIdx - 1), false));
   }

package/src/themes/policy.ts

@@ -270,7 +270,16 @@ export const DEFAULT_WRAP = true;
 // boolean globals field — the same two members the bundled default's
 // `cycle: [...]` toggle writes and the parse below reads. Spelled once so a
 // toggle cannot write a member the resolver refuses to parse.
-export const BOOLEAN_MEMBERS = ["true", "false"] as const;
+// [LAW:one-source-of-truth] The two members, named, because their ORDER is
+// meaningful and differs per control: a cycle's members are ordered
+// default-state-first (an unwritten key counts as the first member and clicks
+// to the second), so `autoWrap` — on by default — cycles ["true","false"]
+// while `persist?` — off by default — cycles [BOOLEAN_FALSE, BOOLEAN_TRUE].
+// Spelling the members rather than reversing the pair keeps each declaration's
+// default state readable at its own site.
+export const BOOLEAN_TRUE = "true";
+export const BOOLEAN_FALSE = "false";
+export const BOOLEAN_MEMBERS = [BOOLEAN_TRUE, BOOLEAN_FALSE] as const;
 
 // [LAW:one-source-of-truth] The one statement of the globals.padding default
 // (one space per side inside each segment cell — current behavior, matching the
@@ -287,8 +296,16 @@ export const PADDING_RANGE = { min: 0, max: 16 } as const;
 // [LAW:parse-dont-validate] A SessionState string to a boolean, or null for
 // anything else. `??` in effectiveGlobal (never `||`) is what keeps a parsed
 // `false` a real answer rather than falling through to the default.
-function parseBoolean(raw: string): boolean | null {
-  return raw === "true" ? true : raw === "false" ? false : null;
+//
+// [LAW:one-source-of-truth] Exported because SessionState holds strings and
+// BOOLEAN_MEMBERS above is the one spelling of a boolean in that store — so
+// every reader of a boolean session key parses it HERE, not with its own
+// truthiness rule. The second reader is the dual-destination action's
+// `persistWhen` selector (src/render/action.ts): "is persist? checked" is the
+// same question `autoWrap`'s toggle asks of its own key, and a bespoke
+// `raw !== ""` there would accept values this parse rejects.
+export function parseSessionBoolean(raw: string): boolean | null {
+  return raw === BOOLEAN_TRUE ? true : raw === BOOLEAN_FALSE ? false : null;
 }
 
 // [LAW:parse-dont-validate] A SessionState string to a padding value inside the
@@ -313,7 +330,7 @@ export function effectiveAutoWrap(
     sessionAutoWrap,
     globalsAutoWrap,
     DEFAULT_WRAP,
-    parseBoolean,
+    parseSessionBoolean,
   );
 }