@promptctl/cc-candybar 1.39.0 → 1.40.0

package/src/daemon/server.ts

@@ -63,20 +63,8 @@ import { buildDebugSnapshot } from "./debug";
 import { DEBUG_WHATS, isDebugWhat } from "./debug-types";
 import { expandHome } from "../config/dsl-loader.js";
 import { renderDsl } from "../dsl/render.js";
-import {
-  effectiveStripStyle,
-  effectiveAutoWrap,
-  effectivePadding,
-  effectiveThemeName,
-  effectiveLookName,
-  lookKeyByName,
-  paletteForThemeName,
-} from "../themes/index.js";
-import {
-  effectivePresetName,
-  presetGlobals,
-  presetIsCustomized,
-} from "../config/presets.js";
+import { lookKeyByName, paletteForThemeName } from "../themes/index.js";
+import { presetIsCustomized } from "../config/presets.js";
 import {
   renderStripCells,
   DEFAULT_CHARSET,
@@ -90,7 +78,11 @@ import {
 } from "../render/strip.js";
 import { applyClaudeCodeReserve } from "../utils/terminal-width.js";
 import type { RichText } from "@promptctl/rich-js";
-import { buildRenderPayload, type EffectiveGlobals } from "./render-payload.js";
+import {
+  buildRenderPayload,
+  resolveEffectiveGlobals,
+  type EffectiveGlobals,
+} from "./render-payload.js";
 import { ContextProvider } from "../segments/context.js";
 import { MetricsProvider } from "../segments/metrics.js";
 import { TmuxService } from "../segments/tmux.js";
@@ -860,83 +852,28 @@ async function handleRequest(req: Request): Promise<HandledRequest> {
       // No special-case branches — same composition every render.
       let body = "";
       if (entry.state !== null) {
-        // [LAW:one-source-of-truth] Resolve the effective theme ONCE — the
-        // session's chosen theme (SessionState) over the config default. This
-        // single name drives BOTH the payload's `theme.effective` field (the
-        // trigger label reads it) AND the rendered basePalette below, so a label
-        // and the colors can never disagree. Resolved here, before the payload
-        // build, so it can be threaded into the sole payload assembler.
-        //
-        // [LAW:one-source-of-truth] Every globals field a menu/stepper can
-        // persist (candybar-config-engine-71o.3), resolved ONCE into one
-        // struct: theme/look/style/autoWrap/padding compose the session's click
-        // (SessionState) over the config default over a floor — a click
-        // recolors/reshapes the whole bar on the next render; charset and
-        // colorCompatibility describe the TERMINAL rather than a taste and so
-        // have no SessionState half at all, making the config global over its
-        // floor constant their whole resolution. This struct feeds
-        // BOTH the payload's `*.effective` fields (trigger labels) AND
-        // renderOpts below (the actual render) — one resolution, two readers,
-        // so a label can never disagree with what was rendered.
-        //
-        // [LAW:one-source-of-truth] The PRESET resolves FIRST, because every
-        // other field below reads globals — and which globals is exactly what
-        // the preset decides. `presetGlobals` is the config's globals with the
-        // active fragment's shallow-merged over them, so the preset sits at its
-        // one documented place in the precedence chain (bundled default < user
-        // file < persisted overrides < ACTIVE PRESET < session pick — see
-        // src/config/presets.ts and docs/interaction-authoring.md): later than
-        // everything read per cache ENTRY, earlier than every session click,
-        // which is the order the `??` chains below already enforce by reading
-        // SessionState first. There is no "does a preset apply?" branch — the
-        // floor preset's empty fragment merges as a no-op
-        // [LAW:dataflow-not-control-flow].
-        const preset = effectivePresetName(
-          sessionState.get(req.hookData.session_id, "preset"),
-          entry.state.config.globals.preset,
-          entry.state.config.presets,
-        );
-        const globals = presetGlobals(entry.state.config, preset);
-        const effective: EffectiveGlobals = {
-          preset,
+        // [LAW:one-source-of-truth] Every globals field resolved ONCE per
+        // render, here — before the payload build, so the same struct feeds
+        // BOTH the payload's `*.effective` fields (what a trigger label says)
+        // AND renderOpts below (what actually renders). One resolution, two
+        // readers, so a label can never disagree with the bar. The precedence
+        // the resolver applies, and why each rung sits where it does, lives
+        // with the chain (resolveEffectiveGlobals, and src/config/presets.ts).
+        // Read alongside the config, from the same entry, in one statement —
+        // which is exactly what the closure below claims about it.
+        const presetRootOps = entry.state.presetRootOps;
+        const effective: EffectiveGlobals = resolveEffectiveGlobals(
+          entry.state.config,
+          (key: string) => sessionState.get(req.hookData.session_id, key),
           // [LAW:one-source-of-truth] brandon-layout-edit-2gc.5 — read from
           // THIS entry's own presetRootOps (the record that fed the SAME
           // reload that produced entry.state.config), never a fresh
           // loadOverrides() here — a second read could race a concurrent
-          // write and disagree with the tree that actually rendered.
-          presetCustomized: presetIsCustomized(
-            entry.state.presetRootOps,
-            preset,
-          ),
-          theme: effectiveThemeName(
-            sessionState.get(req.hookData.session_id, "theme"),
-            globals.palette,
-          ),
-          look: effectiveLookName(
-            sessionState.get(req.hookData.session_id, "look"),
-            globals.look,
-            entry.state.config.looks,
-          ),
-          style: effectiveStripStyle(
-            sessionState.get(req.hookData.session_id, "style"),
-            globals.style,
-          ),
-          autoWrap: effectiveAutoWrap(
-            sessionState.get(req.hookData.session_id, "autoWrap"),
-            globals.autoWrap,
-          ),
-          padding: effectivePadding(
-            sessionState.get(req.hookData.session_id, "padding"),
-            globals.padding,
-          ),
-          // charset and colorCompatibility have no session half by design —
-          // they describe the terminal, not a taste (see CHARSETS in
-          // themes/policy.ts) — so the config global over its floor is their
-          // whole resolution.
-          charset: globals.charset ?? DEFAULT_CHARSET,
-          colorCompatibility:
-            globals.colorCompatibility ?? DEFAULT_COLOR_COMPATIBILITY,
-        };
+          // write and disagree with the tree that actually rendered. That is
+          // why it arrives as a closure over this entry rather than being
+          // looked up inside the resolver.
+          (preset: string) => presetIsCustomized(presetRootOps, preset),
+        );
         const payload = await buildRenderPayload(
           req.hookData,
           payloadDeps,
@@ -956,6 +893,10 @@ async function handleRequest(req: Request): Promise<HandledRequest> {
         // SAME `effective` struct the payload was just built from — no second
         // `?? DEFAULT_X` computation to drift from it.
         renderOpts.style = effective.style;
+        // The `plain` joiner's cell separator. Assigned unconditionally like
+        // every field around it: `undefined` is a value pickJoiner already
+        // reads as "PlainJoiner's own default", not an absence to branch on.
+        renderOpts.separator = effective.separator;
         renderOpts.wrap = effective.autoWrap;
         renderOpts.padding = effective.padding;
         renderOpts.charset = effective.charset;

package/src/demo/dsl.ts

@@ -30,21 +30,10 @@ import { VariableStore } from "../var-system/store.js";
 import { SourceRegistry } from "../var-system/sources.js";
 import { SessionState } from "../daemon/session-state.js";
 import { listResolvablePaletteNames } from "../themes/policy.js";
-import {
-  effectiveThemeName,
-  effectiveLookName,
-  effectiveAutoWrap,
-  effectivePadding,
-  lookKeyByName,
-  paletteForThemeName,
-} from "../themes/index.js";
-import { effectivePresetName, presetGlobals } from "../config/presets.js";
+import { lookKeyByName, paletteForThemeName } from "../themes/index.js";
+import { resolveEffectiveGlobals } from "../daemon/render-payload.js";
 import { registerDslConfig, renderDsl } from "../dsl/render.js";
-import {
-  DEFAULT_CHARSET,
-  DEFAULT_COLOR_COMPATIBILITY,
-  DEFAULT_TERMINAL_WIDTH,
-} from "../render/strip.js";
+import { DEFAULT_TERMINAL_WIDTH } from "../render/strip.js";
 import { applyClaudeCodeReserve } from "../utils/terminal-width.js";
 
 const FRAMES = 4;
@@ -83,18 +72,18 @@ const payload = {
 // globals every other option reads — the same preset-first order server.ts and
 // check.ts resolve in, so the demo prints the arrangement a fresh session opens
 // in.
-const preset = effectivePresetName(null, config.globals.preset, config.presets);
-const globals = presetGlobals(config, preset);
-const basePalette = paletteForThemeName(
-  effectiveThemeName(null, globals.palette),
-);
-// Same fresh-session resolution one dimension over: the config-default look
-// over the "none" identity floor — the exact mirror of the daemon's per-render
-// effectiveLookName → lookKeyByName chain.
-const lookKey = lookKeyByName(
-  config.looks,
-  effectiveLookName(null, globals.look, config.looks),
+// [LAW:one-source-of-truth] THE daemon's resolver, not a mirror of it — a
+// fresh-session pick reader (null for every key) and no overrides log to be
+// customized by. The demo previously restated this chain field by field and had
+// already drifted: it hardcoded `style: "powerline"` below and so ignored a
+// config's own `globals.style`.
+const effective = resolveEffectiveGlobals(
+  config,
+  () => null,
+  () => false,
 );
+const basePalette = paletteForThemeName(effective.theme);
+const lookKey = lookKeyByName(config.looks, effective.look);
 
 // A fresh store + registry for this run. (A hot-reloading daemon would
 // dispose() the old pair and build new ones — see registerDslConfig's docs.)
@@ -128,26 +117,21 @@ try {
       payload,
       basePalette,
       {
-        style: "powerline",
-        // Same resolution the daemon applies: the config global over the
-        // truecolor default floor.
-        colorCompatibility:
-          globals.colorCompatibility ?? DEFAULT_COLOR_COMPATIBILITY,
+        style: effective.style,
+        separator: effective.separator,
+        colorCompatibility: effective.colorCompatibility,
         // [LAW:one-source-of-truth] Demo applies the same Claude-Code-UI
         // reserve the daemon does so demo output matches the bytes a real
         // statusline would emit at the same terminal width.
         width: applyClaudeCodeReserve(
           process.stdout.columns ?? DEFAULT_TERMINAL_WIDTH,
         ),
-        // Same resolvers the daemon applies, with a null session pick — the
-        // demo has no SessionState, so both land on the config default over
-        // their floor.
-        wrap: effectiveAutoWrap(null, globals.autoWrap),
-        padding: effectivePadding(null, globals.padding),
-        charset: globals.charset ?? DEFAULT_CHARSET,
+        wrap: effective.autoWrap,
+        padding: effective.padding,
+        charset: effective.charset,
       },
       undefined,
-      { look: lookKey, preset },
+      { look: lookKey, preset: effective.preset },
     );
     process.stdout.write(`  ${line}\n`);
     if (frame < FRAMES - 1) await sleep(FRAME_INTERVAL_MS);

package/src/themes/policy.ts

@@ -52,14 +52,30 @@ export function resolvePaletteName(name: string): string {
 // default rather than throw or render something the label disagrees with
 // [LAW:no-silent-failure] — the caller publishes what this returns as
 // `<field>.effective`, so bar and label always trace to one value.
+//
+// [LAW:one-source-of-truth] `staged` is the RIGHTMOST rung of the precedence
+// chain documented in src/config/presets.ts — a fragment some transient MODE of
+// the bar puts on top while it is on (today: edit mode's `editGlobals`). It
+// outranks even the session pick because it is decided LATER: a user picks a
+// style, then afterwards enters edit mode. That is the same lifetime rule that
+// forced the preset's own position, applied one rung further along, which is
+// why it is a parameter of THIS function rather than a check at any call site —
+// a chain with a rung missing from one field is exactly the drift a single
+// resolver exists to prevent.
+//
+// [LAW:dataflow-not-control-flow] Absent ⇒ `undefined`, which the `??` chain
+// skips by the same code path a session that never clicked skips its own rung.
+// There is no "is edit mode on" branch anywhere below this line; the mode is
+// carried entirely by whether this argument has a value.
 export function effectiveGlobal<T>(
+  staged: T | null | undefined,
   sessionPick: string | null,
   configDefault: T | null | undefined,
   floor: T,
   parseSession: (raw: string) => T | null,
 ): T {
   const picked = sessionPick === null ? null : parseSession(sessionPick);
-  return picked ?? configDefault ?? floor;
+  return staged ?? picked ?? configDefault ?? floor;
 }
 
 // The theme name a render should use, as data.
@@ -70,10 +86,12 @@ export function effectiveGlobal<T>(
 // parse is identity: there is no membership to check here, and pretending
 // otherwise would collapse names `paletteForThemeName` handles fine.
 export function effectiveThemeName(
+  stagedPalette: string | undefined,
   sessionTheme: string | null,
   globalsPalette: string | undefined,
 ): string {
   return effectiveGlobal(
+    stagedPalette,
     sessionTheme,
     globalsPalette,
     "textual-dark",
@@ -110,7 +128,12 @@ export function listResolvablePaletteNames(): readonly string[] {
 //
 // The floor's membership is a load-time guarantee, not a runtime hope: the
 // bundled stdlib ships it and merge-by-name cannot remove it.
+//
+// The staged rung runs through the SAME membership parse the other two do: a
+// fragment naming a member the config does not declare is no more a pick than a
+// stale session entry is, and collapses one rung onward rather than throwing.
 export function effectiveMemberName(
+  stagedName: string | undefined,
   sessionPick: string | null,
   configDefault: string | undefined,
   floor: string,
@@ -119,6 +142,7 @@ export function effectiveMemberName(
   const member = (raw: string): string | null =>
     Object.prototype.hasOwnProperty.call(declared, raw) ? raw : null;
   return effectiveGlobal(
+    stagedName === undefined ? null : member(stagedName),
     sessionPick,
     member(configDefault ?? floor),
     floor,
@@ -133,11 +157,18 @@ export function effectiveMemberName(
 // carries. A named wrapper (not a bare call at each site) so the floor is
 // spelled once and the three call sites cannot disagree about it.
 export function effectiveLookName(
+  stagedLook: string | undefined,
   sessionLook: string | null,
   globalsLook: string | undefined,
   declaredLooks: Readonly<Record<string, ThemeKey>>,
 ): string {
-  return effectiveMemberName(sessionLook, globalsLook, "none", declaredLooks);
+  return effectiveMemberName(
+    stagedLook,
+    sessionLook,
+    globalsLook,
+    "none",
+    declaredLooks,
+  );
 }
 
 // [LAW:single-enforcer] The one place an effective look NAME becomes the
@@ -196,11 +227,16 @@ export function isStripStyle(value: string): value is StripStyle {
 // [LAW:one-source-of-truth]; test/session-globals.test.ts pins it with a stale
 // pick over a valid non-floor default, the case the old tests never exercised.
 export function effectiveStripStyle(
+  stagedStyle: StripStyle | undefined,
   sessionStyle: string | null,
   globalsStyle: StripStyle | undefined,
 ): StripStyle {
-  return effectiveGlobal(sessionStyle, globalsStyle, "powerline", (raw) =>
-    isStripStyle(raw) ? raw : null,
+  return effectiveGlobal(
+    stagedStyle,
+    sessionStyle,
+    globalsStyle,
+    "powerline",
+    (raw) => (isStripStyle(raw) ? raw : null),
   );
 }
 
@@ -323,10 +359,12 @@ function parsePadding(raw: string): number | null {
 // Whether a render wraps over-wide rows, as data. The session's pick over the
 // config default over the on floor — `effectiveGlobal` with a boolean domain.
 export function effectiveAutoWrap(
+  stagedAutoWrap: boolean | undefined,
   sessionAutoWrap: string | null,
   globalsAutoWrap: boolean | undefined,
 ): boolean {
   return effectiveGlobal(
+    stagedAutoWrap,
     sessionAutoWrap,
     globalsAutoWrap,
     DEFAULT_WRAP,
@@ -341,10 +379,12 @@ export function effectiveAutoWrap(
 // own default is the honest answer rather than a render at a width nobody
 // chose.
 export function effectivePadding(
+  stagedPadding: number | undefined,
   sessionPadding: string | null,
   globalsPadding: number | undefined,
 ): number {
   return effectiveGlobal(
+    stagedPadding,
     sessionPadding,
     globalsPadding,
     DEFAULT_PADDING,