@promptctl/cc-candybar 1.9.0 → 1.11.0

package/src/render/strip.ts

@@ -9,8 +9,10 @@ import {
   renderToString,
   type Joiner,
   type ColorSystemSpec,
+  type PowerlineJoinerOptions,
+  type CapsuleJoinerOptions,
 } from "@promptctl/rich-js";
-import type { StripStyle } from "../themes/policy.js";
+import type { Charset, StripStyle } from "../themes/policy.js";
 
 export interface RenderedSegmentLike {
   type: string;
@@ -19,11 +21,11 @@ export interface RenderedSegmentLike {
   fgHex?: string;
 }
 
-// [LAW:one-source-of-truth] `StripStyle` and its value list live in
-// themes/policy.ts (the style-identifier policy module, importable by the
+// [LAW:one-source-of-truth] `StripStyle`/`Charset` and their value lists live
+// in themes/policy.ts (the render-identifier policy module, importable by the
 // option-source machinery without a render→template-engine cycle). Re-exported
-// here so render-layer consumers can keep importing it from the strip module.
-export type { StripStyle };
+// here so render-layer consumers can keep importing them from the strip module.
+export type { Charset, StripStyle };
 
 // [LAW:one-source-of-truth] Raw terminal cols we assume when the wire
 // didn't give us one (older client, env-stripped spawn). RAW — not
@@ -37,6 +39,18 @@ export const DEFAULT_TERMINAL_WIDTH = 120;
 // (`globals.autoWrap ?? DEFAULT_WRAP`) derives from this constant.
 export const DEFAULT_WRAP = true;
 
+// [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 legacy display.padding). Every resolver of the config global
+// (`globals.padding ?? DEFAULT_PADDING`) derives from this constant.
+export const DEFAULT_PADDING = 1;
+
+// [LAW:one-source-of-truth] The one statement of the globals.charset default
+// (powerline unicode glyphs — current behavior, matching the legacy
+// display.charset). Every resolver of the config global
+// (`globals.charset ?? DEFAULT_CHARSET`) derives from this constant.
+export const DEFAULT_CHARSET: Charset = "unicode";
+
 export interface BuildLineOptions {
   style: StripStyle;
   colorCompatibility: ColorSystemSpec;
@@ -53,20 +67,57 @@ export interface BuildLineOptions {
   // explicitly — encoding "no wrap" as width=Infinity would corrupt the
   // picker's pagination, which reads the same width value.
   wrap: boolean;
+  // [LAW:one-source-of-truth] Spaces inside each segment cell per side
+  // (globals.padding, default 1 — the legacy display.padding, intra-cell,
+  // not rich-js FlexStrip's inter-item gap). Required so every construction
+  // site states the resolved value; the cell builders derive from it and
+  // never re-default.
+  padding: number;
+  // [LAW:one-source-of-truth] Which glyph vocabulary the joiners render with
+  // (globals.charset, default "unicode" — the legacy display.charset).
+  // Required for the same reason as padding: the resolved value reaches every
+  // render explicitly; pickJoiner derives from it and never re-defaults.
+  charset: Charset;
 }
 
-function pickJoiner(style: StripStyle, separator?: string): Joiner {
+// [LAW:dataflow-not-control-flow] Charset variability lives in these VALUES,
+// not in branches: per style, each charset names the joiner-construction
+// options. The unicode entries are empty on purpose — rich-js owns its
+// canonical powerline glyphs (U+E0B0 / U+E0B6+U+E0B4) and restating them here
+// would be a second source that could drift [LAW:one-source-of-truth]. The
+// ascii glyphs are DELIBERATELY single-column (same display width as the
+// unicode caps) so stripChromeCols stays charset-invariant; the
+// measured-chrome pin in test/picker-pagination.test.ts checks that for every
+// style × charset. Widen a glyph and that pin fails loudly.
+const POWERLINE_GLYPHS: Record<Charset, PowerlineJoinerOptions> = {
+  unicode: {},
+  ascii: { glyph: ">" },
+};
+const CAPSULE_GLYPHS: Record<Charset, CapsuleJoinerOptions> = {
+  unicode: {},
+  ascii: { left: "(", right: ")" },
+};
+
+function pickJoiner(
+  style: StripStyle,
+  charset: Charset,
+  separator?: string,
+): Joiner {
   // [LAW:dataflow-not-control-flow] joiner choice is data-driven; one arm per
-  // shape. [LAW:types-are-the-program] Total over StripStyle — the `never`
+  // shape. Style picks the joiner CLASS, charset indexes the glyph options fed
+  // to it — the two dimensions stay orthogonal (any style renders under either
+  // charset). Plain takes no charset lookup: its separator is already user
+  // data (globals.default_separator) and its default (" | ") is ASCII-safe.
+  // [LAW:types-are-the-program] Total over StripStyle — the `never`
   // default makes adding a STRIP_STYLES member a compile error here until it
   // gets a joiner, so the picker's domain can never offer an unrenderable shape.
   switch (style) {
     case "capsule":
-      return new CapsuleJoiner();
+      return new CapsuleJoiner(CAPSULE_GLYPHS[charset]);
     case "plain":
       return new PlainJoiner(separator !== undefined ? { separator } : {});
     case "powerline":
-      return new PowerlineJoiner();
+      return new PowerlineJoiner(POWERLINE_GLYPHS[charset]);
     default: {
       const _exhaustive: never = style;
       return _exhaustive;
@@ -84,10 +135,13 @@ function pickJoiner(style: StripStyle, separator?: string): Joiner {
 // [LAW:dataflow-not-control-flow] / [LAW:types-are-the-program] Total over
 // StripStyle — the `never` default makes adding a STRIP_STYLES member a compile
 // error here until its chrome is declared, the same guard pickJoiner carries. The
-// numbers are the default cap glyphs pickJoiner constructs: powerline appends ONE
-// trailing separator (U+E0B0, 1 col); capsule brackets BOTH edges (U+E0B6 +
-// U+E0B4, 2 cols); plain has no caps. test/picker-pagination.test.ts measures the
-// real rendered chrome against these so the declaration cannot drift from rich-js.
+// numbers are the cap glyphs pickJoiner constructs: powerline appends ONE
+// trailing separator (1 col); capsule brackets BOTH edges (2 cols); plain has no
+// caps. Charset does NOT change these — both glyph vocabularies use
+// single-column caps by construction (see the glyph tables above), which is why
+// this stays total over StripStyle alone. test/picker-pagination.test.ts
+// measures the real rendered chrome against these for every style × charset so
+// the declaration cannot drift from rich-js or from the ascii glyph choice.
 export function stripChromeCols(style: StripStyle): number {
   switch (style) {
     case "powerline":
@@ -103,15 +157,15 @@ export function stripChromeCols(style: StripStyle): number {
   }
 }
 
-function toCell(seg: RenderedSegmentLike): RichText {
-  // Padding mirrors the legacy buildLineFromSegments: one space on each side
-  // of the segment text. The joiners sit between cells; padding sits inside.
-  const padded = ` ${seg.text} `;
+function toCell(seg: RenderedSegmentLike, padding: number): RichText {
+  // [LAW:one-source-of-truth] Intra-cell padding derives from the one resolved
+  // globals.padding value on BuildLineOptions — the joiners sit between cells;
+  // padding sits inside, inheriting the cell's wrapping style (bg fill).
   const style = new Style({
     bgcolor: seg.bgHex || undefined,
     color: seg.fgHex || undefined,
   });
-  return new RichText(padded, { style, end: "", noWrap: true });
+  return new RichText(seg.text, { style, end: "", noWrap: true }).pad(padding);
 }
 
 /**
@@ -132,7 +186,7 @@ export function renderStripCells(
   options: BuildLineOptions,
 ): string {
   if (cells.length === 0) return "";
-  const joiner = pickJoiner(options.style, options.separator);
+  const joiner = pickJoiner(options.style, options.charset, options.separator);
   if (options.wrap && Number.isFinite(options.width)) {
     const flex = new FlexStrip([...cells], { joiner });
     const out = renderToString(flex, {
@@ -156,5 +210,8 @@ export function buildLineStrip(
   segments: readonly RenderedSegmentLike[],
   options: BuildLineOptions,
 ): string {
-  return renderStripCells(segments.map(toCell), options);
+  return renderStripCells(
+    segments.map((seg) => toCell(seg, options.padding)),
+    options,
+  );
 }

package/src/template-engine/layout.ts

@@ -30,6 +30,15 @@ export interface SegmentLayoutOptions {
   justify: JustifyMode;
   /** Overflow strategy when content exceeds a fixed width. Ignored when "auto". */
   truncate: TruncateMode;
+  /**
+   * Spaces synthesized inside the collapsed cell on each side (the resolved
+   * globals.padding). [LAW:types-are-the-program] Required so every layout
+   * site states the value — the walk threads the one render-wide resolution;
+   * there is no per-site re-default. Applied BEFORE width sizing, so padding
+   * sits inside a fixed `width` (the legacy intra-cell semantics: the joiners
+   * sit between cells; padding sits inside the bg fill).
+   */
+  padding: number;
   /** Glyph inserted at the overflow cut point. Default "…". */
   truncateMarker?: string;
   /**
@@ -95,11 +104,23 @@ export function applySegmentLayout(
   cells: readonly RichText[],
   options: SegmentLayoutOptions,
 ): RichText[] {
-  const { width, justify, truncate, truncateMarker = "…", baseStyle } = options;
+  const {
+    width,
+    justify,
+    truncate,
+    truncateMarker = "…",
+    baseStyle,
+    padding,
+  } = options;
 
   if (cells.length === 0) return [];
 
-  const cell = collapseToCell(cells, baseStyle);
+  // [LAW:one-source-of-truth] The DSL path's ONE intra-cell padding
+  // application — the same rich-js pad primitive toCell (render/strip.ts)
+  // uses on the legacy shape, threading the same resolved globals.padding.
+  // pad() shifts spans, so OSC-8 link regions survive; the spaces inherit
+  // the cell's wrapping style, so the segment bg is continuous.
+  const cell = collapseToCell(cells, baseStyle).pad(padding);
   if (width === "auto") return [cell];
 
   if (cell.cellLength > width) {

package/src/themes/policy.ts

@@ -79,3 +79,20 @@ export function effectiveStripStyle(
   const chosen = sessionStyle ?? globalsStyle ?? "powerline";
   return isStripStyle(chosen) ? chosen : "powerline";
 }
+
+// --- Joiner charset identifiers ---
+
+// [LAW:one-source-of-truth][LAW:types-are-the-program] The single canonical set
+// of glyph vocabularies the strip joiners can render with (the legacy
+// display.charset). Same species as STRIP_STYLES — a closed render-vocabulary
+// enum hosted in this leaf policy module so the config loader (validation +
+// JSON-schema emit) and the render layer (glyph dispatch) both derive from one
+// literal without a config↔render cycle [LAW:one-way-deps]. "ascii" swaps the
+// powerline-private-use cap glyphs (U+E0Bx — tofu without a Nerd Font) for
+// plain-ASCII equivalents; it is orthogonal to StripStyle: style picks the
+// joiner SHAPE, charset picks the glyph VALUES fed to it.
+// [config-only] Unlike STRIP_STYLES there is no SessionState/click half, so no
+// narrowing guard or effective* resolver — the config global over the default
+// is the whole resolution.
+export const CHARSETS = ["unicode", "ascii"] as const;
+export type Charset = (typeof CHARSETS)[number];