@promptctl/cc-candybar 1.42.1 → 1.43.0

package/src/segments/tmux.ts

@@ -1,74 +0,0 @@
-import { launch } from "../proc/launch";
-import { debug } from "../utils/logger";
-import { ABSENT, failed, ok, type Outcome } from "../utils/outcome";
-
-// [LAW:single-enforcer] One module-level cache of tmux session lookups, keyed
-// by the tmux *socket path* (the substring of `$TMUX` before the first comma —
-// `$TMUX` is "<socket>,<client-pid>,<session-num>"). The session ID for a
-// given socket doesn't change for the life of the daemon, so this collapses
-// N per-render `tmux display-message` spawns to one per (daemon, socket).
-//
-// [LAW:dataflow-not-control-flow] The lookup always runs the same path: read
-// the env key, look up the cached value, spawn-and-record on miss, return.
-// Variability lives in the cached values, not in whether the spawn happens.
-//
-// Value type: the resolved Outcome. `ok` is the session id; `absent` means
-// the previous resolution reported an empty session id (definitively no
-// session); `failed` means the spawn itself failed. Both non-ok outcomes are
-// durable for the daemon's lifetime — retrying every render would burn
-// subprocesses without changing the answer — but the cached `failed` still
-// flows to the payload boundary as a value, so the failure stays visible
-// instead of being demoted to absence ([LAW:no-silent-failure]). A map miss
-// (undefined) means not yet attempted — the next call will spawn.
-const sessionIdCache = new Map<string, Outcome<string>>();
-
-// [LAW:one-source-of-truth] One place that extracts the socket-path prefix
-// from `$TMUX`. Empty string means "tmux env not set" — the resolver returns
-// early before reaching the cache, but we still tolerate the empty key in
-// case a future caller invokes us without the early-return.
-function tmuxCacheKey(raw: string | undefined): string {
-  if (!raw) return "";
-  const comma = raw.indexOf(",");
-  return comma < 0 ? raw : raw.slice(0, comma);
-}
-
-// Exposed for tests only — resets the cache so each test starts cold.
-export function __resetTmuxCacheForTest(): void {
-  sessionIdCache.clear();
-}
-
-export class TmuxService {
-  async getSessionId(): Promise<Outcome<string>> {
-    if (!process.env.TMUX_PANE) {
-      return ABSENT;
-    }
-
-    const cacheKey = tmuxCacheKey(process.env.TMUX);
-    const cached = sessionIdCache.get(cacheKey);
-    if (cached !== undefined) return cached;
-
-    debug(`Getting tmux session ID, TMUX_PANE: ${process.env.TMUX_PANE}`);
-
-    const result = await launch({
-      bin: "tmux",
-      args: ["display-message", "-p", "#S"],
-      timeoutMs: 1000,
-      category: "tmux",
-    });
-
-    // A failed tmux invocation in a session that has $TMUX_PANE set is a real
-    // misconfiguration; cache it so renders don't re-spawn, and let the
-    // outcome carry the reason to the payload boundary's log site.
-    const outcome: Outcome<string> = !result.ok
-      ? failed(`tmux display-message: ${result.reason}`)
-      : result.stdout.trim()
-        ? ok(result.stdout.trim())
-        : ABSENT;
-    sessionIdCache.set(cacheKey, outcome);
-    return outcome;
-  }
-
-  isInTmux(): boolean {
-    return !!process.env.TMUX_PANE;
-  }
-}

package/src/template-engine/cells.ts

@@ -1,90 +0,0 @@
-// [LAW:dataflow-not-control-flow] The fragment walk is unconditional: every
-// fragment is visited; style.link (a value on the fragment) decides whether
-// it becomes its own cell or coalesces with neighbours. No branching on
-// "are there any cells" — variability lives entirely in the data.
-//
-// [LAW:one-type-per-behavior] Cells are RichText. There is no parallel
-// "cell" type with a single-bg invariant: rich-js's joiner protocol asks
-// each item only for its edge style, so the interior can vary freely.
-// What was previously expressed as "split this run into N cells at bg
-// boundaries" or "lift the modal style to cell-level so parts survive a
-// slice" is now structurally impossible to need — RichText carries per-
-// character styling via spans, and every layout op (truncate / align /
-// pad / slice) preserves spans by construction.
-
-import { RichText } from "@promptctl/rich-js";
-import type { Style } from "@promptctl/rich-js";
-
-/**
- * Convert template-engine fragments (`RichText[]`) into Strip cells
- * (`RichText[]`), splitting at OSC-8 link boundaries so each clickable
- * region is its own cell. Non-link runs coalesce into one cell whose
- * interior styling is carried as spans.
- *
- * `baseStyle` is the segment-level default (resolved bg + fg). It becomes
- * the cell's wrapping style so segment-wide bg+fg cascade across every
- * character, and per-fragment fg overlays land as spans on top.
- *
- * [LAW:single-enforcer] The only mapper from template fragments to Strip
- * cells. Callers do not assemble cells by hand.
- */
-export function fragmentsToCells(
-  fragments: RichText[],
-  baseStyle?: Style,
-): RichText[] {
-  const cells: RichText[] = [];
-  let group: RichText[] = [];
-
-  const flush = () => {
-    if (!group.length) return;
-    const cell = buildCell(group, baseStyle);
-    if (cell.plain.length > 0) cells.push(cell);
-    group = [];
-  };
-
-  for (const frag of fragments) {
-    if (frag.style.link) {
-      flush();
-      const cell = buildCell([frag], baseStyle);
-      if (cell.plain.length > 0) cells.push(cell);
-    } else {
-      group.push(frag);
-    }
-  }
-  flush();
-
-  return cells;
-}
-
-function buildCell(fragments: RichText[], baseStyle?: Style): RichText {
-  // [LAW:types-are-the-program] Each fragment carries its own style (and
-  // possibly spans). We merge baseStyle UNDER each fragment's style before
-  // assembling so the segment-wide default flows through every character,
-  // with the fragment's own style winning on overlap. That merged style
-  // then lands as a span on the assembled RichText, so per-fragment styles
-  // are addressable as overlays.
-  const layered =
-    baseStyle !== undefined && !baseStyle.isNull
-      ? fragments.map((f) => withBaseStyle(f, baseStyle))
-      : fragments;
-  const cell = RichText.fromFragments(layered);
-  cell.end = "";
-  cell.noWrap = true;
-  // [LAW:one-source-of-truth] For a single-fragment cell (a link cell, or a
-  // single-styled non-link fragment), the cell's wrapping style IS that
-  // fragment's effective style. This keeps the link / linked-region claim
-  // structurally at cell level (where joiners and click dispatch read it)
-  // and matches the old per-cell-style contract.
-  if (layered.length === 1) {
-    cell.style = layered[0]!.style;
-  } else if (baseStyle !== undefined && !baseStyle.isNull) {
-    cell.style = baseStyle;
-  }
-  return cell;
-}
-
-function withBaseStyle(f: RichText, base: Style): RichText {
-  const copy = f.copy();
-  copy.style = base.add(f.style);
-  return copy;
-}

package/src/template-engine/colors.ts

@@ -1,124 +0,0 @@
-// [LAW:single-enforcer] All per-segment bg/fg resolution flows through
-// resolveSegmentColors. No second path; a second path would silently drift
-// from the ordered pipeline this function owns.
-//
-// [LAW:no-ambient-temporal-coupling] That ordering — publish the segment's
-// palette, resolve bg, publish bg, resolve fg, then hand the body its turn —
-// is not incidental execution order that happens to work. It is the phase
-// structure of a segment's color resolution, and this function is its one
-// owner. Each phase's output is *published* into the active-segment record
-// before the next phase runs, so a later template can read an earlier
-// phase's result (`fg: '{{ contrastOn (bgOf) }}'`) and an earlier one
-// cannot read a later one — it gets a message naming the phase instead.
-//
-// [LAW:dataflow-not-control-flow] Steps execute unconditionally; the option
-// values (undefined template = no spec) are what decides the output, not
-// whether steps run. Absent bg or fg → Style fields are undefined → Style.isNull
-// → fragmentsToStripCells's baseStyle merge is a no-op, cells flow through
-// unchanged.
-
-import {
-  Style,
-  ColorSpec,
-  resolveColorRef,
-  ColorRefError,
-} from "@promptctl/rich-js";
-import type { ColorRgba, Palette } from "@promptctl/rich-js";
-import type { RichText } from "@promptctl/rich-js";
-import type { Template } from "@promptctl/go-template-js";
-import type { ActiveSegmentRef } from "../render/active-segment.js";
-
-export class ColorSpecError extends Error {
-  constructor(spec: string, role: "bg" | "fg", detail: string) {
-    super(`Invalid ${role} color ${JSON.stringify(spec)}: ${detail}`);
-    this.name = "ColorSpecError";
-  }
-}
-
-/**
- * Resolve a segment's `bg:` and `fg:` templates into the Style that becomes
- * its baseStyle, publishing each phase's result into `ref` as it goes.
- *
- * A `bg:`/`fg:` field is a template evaluated to a **color reference** — a
- * palette variable name (`"surface-active"`) or a `#RRGGBB` literal. Since
- * rich-js's `resolveColorRef` accepts both and is idempotent, the plain
- * authoring form and a computed one take the identical path:
- *
- * ```json5
- * bg: "surface-active"                             // a name, evaluated as itself
- * bg: '{{ darken (color "surface-active") 1 }}'    // a computed literal
- * ```
- *
- * There is no "is this a name or a color" branch anywhere — one total
- * function over both. [LAW:dataflow-not-control-flow]
- *
- * Undefined template → that color is not set in the returned Style, so cells
- * fall through to their own style (or no color if they have none).
- *
- * Hue rotation and looks are not this function's concern: they live upstream
- * as WHICH palette it is handed, so bg, fg, and the body all resolve from one
- * palette and their theme-designed relationships are preserved.
- */
-export function resolveSegmentColors(
-  ref: ActiveSegmentRef,
-  segName: string,
-  palette: Palette,
-  bgTemplate: Template<RichText> | undefined,
-  fgTemplate: Template<RichText> | undefined,
-  scope: object,
-): Style {
-  // Phase 0 — the palette is live from here until the walk clears it, so
-  // `{{ color … }}` in the bg template, the fg template, and the body all read
-  // this one palette. `bg` starts undefined: it is what phase 1 computes.
-  const active = { segName, palette, bg: undefined as ColorRgba | undefined };
-  ref.current = active;
-
-  // Phase 1 — background.
-  const bgSpec = evalToPlainText(bgTemplate, scope);
-  const bgColor =
-    bgSpec !== undefined ? resolveRef(palette, bgSpec, "bg") : undefined;
-
-  // Phase 2 — publish it, then foreground, which may now ask about it.
-  active.bg = bgColor;
-  const fgSpec = evalToPlainText(fgTemplate, scope);
-  const fgColor =
-    fgSpec !== undefined ? resolveRef(palette, fgSpec, "fg") : undefined;
-
-  return new Style({
-    bgcolor: bgColor !== undefined ? ColorSpec.fromRgba(bgColor) : undefined,
-    color: fgColor !== undefined ? ColorSpec.fromRgba(fgColor) : undefined,
-  });
-}
-
-// Evaluate a template against scope and flatten all fragments to plain text.
-// Returns undefined when no template is configured (no bg/fg override).
-function evalToPlainText(
-  template: Template<RichText> | undefined,
-  scope: object,
-): string | undefined {
-  if (template === undefined) return undefined;
-  return template
-    .evaluate(scope)
-    .map((f) => f.plain)
-    .join("");
-}
-
-// [LAW:one-source-of-truth] The same rich-js checkpoint the `{{ color }}`
-// template function crosses, so a reference that works in a body works in a
-// `bg:` field and vice versa. Re-thrown with the field's role attached —
-// rich-js knows the reference failed, only cc-candybar knows it came from a
-// `fg:`. [LAW:no-silent-failure] never a substituted default: a broken color
-// reference is a config bug, and the fix is the config.
-function resolveRef(
-  palette: Palette,
-  ref: string,
-  role: "bg" | "fg",
-): ColorRgba {
-  try {
-    return resolveColorRef(palette, ref);
-  } catch (e) {
-    if (e instanceof ColorRefError)
-      throw new ColorSpecError(ref, role, e.message);
-    throw e;
-  }
-}

package/src/template-engine/engine.ts

@@ -1,108 +0,0 @@
-// [LAW:one-source-of-truth] One Engine instance covers all segment template
-// evaluation. Callers parse their template once (engine.parse(src)) and call
-// template.evaluate(scope) per render — the expensive parse step is not
-// repeated per render cycle.
-//
-// Function registry (closed set for cc-candybar):
-//  • Go builtins (always registered by the engine): printf, print, println,
-//    eq/ne/lt/gt/le/ge, and/or/not, len, index, slice, call.
-//  • sprigDefaults: default, empty, coalesce, ternary, fromJson, toJson.
-//  • sprigStrings: trunc, lower, upper, replace, trim/trimPrefix/trimSuffix,
-//    split/join, contains, hasPrefix, hasSuffix, and more string utils.
-//  • sprigLists: has (membership test: `has "v" $list`).
-//  • sprigMath: add, sub, mul, div, mod, floor, ceil, round, min, max,
-//    seq, until (round here is shadowed by formatterFuncs' Math.round below).
-//  • sprigDatetime(clock): now, date, ago, unixEpoch, dateInZone, dateModify,
-//    toDate, duration — all reading "now" through the injected clock seam.
-//  • sprigConversions: atoi, int, int64, float64, toString, toStrings
-//    (int here is shadowed by ccCandybarFuncs' var-system cast below).
-//  • sprigDicts: dict, get, set, keys, values, pick, omit, hasKey, merge —
-//    `dict` lets a helper take multiple named inputs through its one dot arg.
-//  • richTextFuncs: fg, bg, bold, italic, link, style (painting) PLUS the
-//    palette-free color math (darken, lighten, mix, contrastOn, readableOn,
-//    shiftHue, scaleChroma, scaleLightness, shiftLightness) — all from rich-js.
-//    Naming a THEME color (`{{ color "primary" }}`) and asking for the current
-//    segment's background (`{{ bgOf }}`) are segment-scoped, so they arrive
-//    through `extraFuncs` from the DSL render layer, which is the only place
-//    that knows which segment is rendering.
-//  • ccCandybarFuncs: basename, dirname, int, string, bool, urlEncode,
-//    themes, styles, sparkline.
-//  • formatterFuncs: minutesUntilReset (clock-reading numeric primitive),
-//    formatInteger, round, formatModelName, shortenModelName. (The cost/token/
-//    budget AND duration/time-remaining formatters moved to DSL helper templates
-//    — see DEFAULT_DSL_CONFIG.helpers.)
-
-import {
-  createEngine,
-  type Engine,
-  type FuncMap,
-  sprigDefaults,
-  sprigStrings,
-  sprigLists,
-  sprigMath,
-  sprigDatetime,
-  sprigConversions,
-  sprigDicts,
-} from "@promptctl/go-template-js";
-import { richTextFuncs, RichText } from "@promptctl/rich-js";
-import { ccCandybarFuncs, formatterFuncs } from "./funcs.js";
-
-// [LAW:single-enforcer] fromString/toString are declared once here.
-// richTextFuncs() provides the theme-independent vocabulary: painting, color
-// math, attributes, links. It needs no configuration, so it is unconditional.
-// [LAW:one-way-deps] `extraFuncs` is an INJECTED FuncMap (e.g. the action +
-// picker feature funcs, built in render/action.ts + render/picker.ts). The
-// generic engine never imports a specific feature — the caller hands it the
-// capability as data, so the dependency runs caller → engine, never engine → feature.
-// [LAW:one-type-per-behavior] extraFuncs? is a value, not a mode — one factory,
-// one engine shape; the data (its presence) governs what's registered.
-// [LAW:single-enforcer] `clock` is the one time source. It feeds sprigDatetime
-// (the funcs that read "now") AND createEngine's clock option, so every
-// time-dependent evaluation in this engine reads from one seam. Defaulted here
-// so the default literal `() => new Date()` lives in exactly one place; callers
-// that omit it (and forwarders passing `undefined`) inherit it unchanged.
-export function createCcCandybarEngine(
-  extraFuncs?: FuncMap,
-  clock: () => Date = () => new Date(),
-): Engine<RichText> {
-  return createEngine<RichText>({
-    fromString: (s) => new RichText(s),
-    toString: (rt) => rt.plain,
-    clock,
-    // [LAW:no-defensive-null-guards] missing fields must throw at the boundary,
-    // not silently produce "<no value>". Callers (SourceRegistry, segments)
-    // depend on MissingFieldError to drive varDefault / defaultEmptyValue.
-    missingKey: "error",
-    funcs: {
-      ...sprigDefaults(),
-      ...sprigStrings(),
-      ...sprigLists(),
-      ...sprigMath(),
-      // [LAW:single-enforcer] one clock seam: the same source createEngine holds.
-      ...sprigDatetime(clock),
-      ...sprigConversions(),
-      // [LAW:types-are-the-program] `dict` is the substrate primitive a helper
-      // uses to receive more than one input through its single dot arg:
-      // `{{ template "budgetStatus" (dict "cost" .x "budget" .y "warn" .z) }}`.
-      // It makes a multi-input formatter's domain exactly {named scalars},
-      // decoupled from any payload's nesting — no per-payload helper variant.
-      ...sprigDicts(),
-      ...richTextFuncs(),
-      // Domain-specific overrides last (wins on collision with sprig aliases).
-      // [LAW:one-source-of-truth] ccCandybarFuncs' `int` is the var-system cast
-      // (toNumber over VarValue); it intentionally shadows sprigConversions' `int`
-      // so a template's `int` keeps one meaning. Position is the override policy.
-      ...ccCandybarFuncs(),
-      // [LAW:one-source-of-truth] formatter funcs delegate to
-      // src/utils/formatters.ts; minutesUntilReset reads the same `clock` seam.
-      // The only sprig collision is `round`: formatterFuncs' Math.round shadows
-      // sprigMath's precision-aware round, registered last so the domain meaning
-      // wins (revisited by the bdi cleanup ticket).
-      ...formatterFuncs(clock),
-      // [LAW:locality-or-seam] Injected feature funcs (the daemon's per-config
-      // engine supplies the `action` + `picker` funcs; resolver-less compile-only
-      // paths do not). Last so a feature can override on collision.
-      ...(extraFuncs ?? {}),
-    },
-  });
-}

package/src/template-engine/funcs.ts

@@ -1,232 +0,0 @@
-// [LAW:one-source-of-truth] Cast semantics live in var-system/types.ts.
-// This module wraps them as FuncMap entries — it does not duplicate logic.
-// [LAW:single-enforcer] The boundary gate (argTypes) lives at the engine
-// dispatch site; the bodies here trust the runtime types they declared.
-
-import { basename as pathBasename, dirname as pathDirname } from "path";
-import type { FuncMap } from "@promptctl/go-template-js";
-import {
-  toNumber,
-  toString,
-  toBool,
-  type VarValue,
-} from "../var-system/types.js";
-import {
-  abbreviatePath,
-  formatInteger,
-  formatModelName,
-  shortenModelName,
-} from "../utils/formatters.js";
-import { listResolvablePaletteNames, STRIP_STYLES } from "../themes/policy.js";
-import { renderSparkline, parseSeries } from "./sparkline.js";
-
-// [LAW:one-source-of-truth] The DSL `themes()` and `styles()` bindings
-// project the SAME canonical sources the set-state validator consults
-// (listResolvablePaletteNames / STRIP_STYLES). A picker (or a config that
-// `range`s over themes() to emit OSC-8 cells) iterates the allow-list the
-// validator will enforce on the resulting click — the list and the gate cannot
-// diverge because there is no second list.
-//
-// Module-init caching is correct by construction: rich-js THEMES is a
-// static import (no dynamic palette registration at runtime) and
-// STRIP_STYLES is a const array. The "reactivity" requirement from the
-// ticket is satisfied vacuously — the lists never change during a
-// daemon lifetime, so a cached snapshot IS the current truth.
-const THEMES_LIST: readonly string[] = listResolvablePaletteNames();
-const STYLES_LIST: readonly string[] = [...STRIP_STYLES];
-
-// [LAW:single-enforcer] Numeric validation lives at ONE boundary — the engine's
-// `int`/`float` argType gate (@promptctl/go-template-js), which proves membership
-// and normalizes the carrier to a JS `number` before the func body runs. `int`
-// admits only finite integer-valued numbers + safe-integer bigints (rejecting
-// fractionals and precision-losing/overflowing bigints loudly at the gate);
-// `float` admits any finite number. So a formatter wrapper receives a clean
-// `number` and needs no bigint guard of its own — the prior `num()` helper was a
-// second enforcer of what the gate now owns, removed when the formatters adopted
-// int/float. [LAW:no-silent-failure] the gate's rejection is the loud failure on
-// a precision-losing integer input; this is not weaker than the old runtime
-// check, it is the same guarantee moved to the true boundary.
-
-// cc-candybar-specific functions not already covered by sprig or Go builtins.
-// The engine also includes sprigDefaults(), sprigStrings(), and sprigLists()
-// which cover: default, trunc, lower, upper, replace, trim/trimPrefix/trimSuffix,
-// split/join, contains/hasPrefix/hasSuffix, has.
-// Go builtins cover: printf, eq/ne/lt/gt/le/ge, and/or/not.
-export function ccCandybarFuncs(): FuncMap {
-  return {
-    // Path operations absent from sprig in this package.
-    basename: {
-      fn: (s: string) => pathBasename(s),
-      argTypes: ["string"],
-    },
-    dirname: {
-      fn: (s: string) => pathDirname(s),
-      argTypes: ["string"],
-    },
-
-    // [LAW:decomposition] Fish-style path abbreviation — one thing: shorten
-    // every segment but the leaf. Composes over the directory template's
-    // already-collapsed output (`~`/project-relative), never duplicating that
-    // logic. Impl in utils/formatters.ts, mirroring formatModelName's split.
-    abbreviatePath: {
-      fn: (s: string) => abbreviatePath(s),
-      argTypes: ["string"],
-    },
-
-    // [LAW:single-enforcer] Type casts delegate to var-system/types.ts.
-    // "value" argType: these funcs enforce their own constraints and emit
-    // a useful TypeError on ambiguous input — no need for the engine gate
-    // to pre-filter (it can't describe the partial-cast semantics anyway).
-    int: {
-      fn: (v: VarValue) => toNumber(v),
-      argTypes: ["value"],
-    },
-    string: {
-      fn: (v: VarValue) => toString(v),
-      argTypes: ["value"],
-    },
-    bool: {
-      fn: (v: VarValue) => toBool(v),
-      argTypes: ["value"],
-    },
-
-    // [LAW:single-enforcer] One URL-encoding function for click-verb URL
-    // construction in templates. encodeURIComponent matches the legacy
-    // src/segments/renderer.ts toolbar/tray renderers, so DSL-emitted
-    // cc-candybar://verb/<value> URLs are byte-identical to legacy ones.
-    // [LAW:types-are-the-program] Domain primitive surfaced by chunk-7/8
-    // migration (vhi.3) — the proposal explicitly budgets "may add one or
-    // two filters during migration." This is one of those.
-    urlEncode: {
-      fn: (s: string) => encodeURIComponent(s),
-      argTypes: ["string"],
-    },
-
-    // [LAW:one-source-of-truth] themes() and styles() are zero-arg
-    // projections of the daemon's canonical domain lists. A picker (or a
-    // hand-authored `range`) expresses "options come from list Y" by
-    // iterating these bindings; the same lists feed the set-state
-    // validator's allow-list checks, so the rendered options are exactly
-    // the values the next click will be allowed to write. No second
-    // enumeration in user config.
-    // [LAW:dataflow-not-control-flow] A range loop over a list IS the
-    // option primitive — `{{ range themes }}…{{ end }}` produces one
-    // rendered cell per allowed value. Adding a theme adds a cell;
-    // removing a theme removes a cell; no template branch on "how many
-    // themes are there."
-    themes: {
-      fn: () => THEMES_LIST,
-      argTypes: [],
-    },
-    styles: {
-      fn: () => STYLES_LIST,
-      argTypes: [],
-    },
-
-    // [LAW:effects-at-boundaries] Pure trend renderer: a numeric series (the
-    // daemon-owned ring, projected through the payload as a delimited string)
-    // becomes a unicode mini-graph. The series crosses the scalar var-system
-    // seam as a string, so the FuncMap slot is "string"; `parseSeries` decodes
-    // it and `renderSparkline` draws it — neither accumulates state. The
-    // optional trailing "int" slot caps the glyph count to fit a cell (the
-    // evaluator validates only supplied args, so `{{ sparkline .series }}` and
-    // `{{ sparkline .series 24 }}` are both well-typed). Returns a bare string;
-    // the engine lifts it to RichText so the segment's fg/bg palette colors the
-    // whole graph — no per-glyph color math here.
-    sparkline: {
-      fn: (series: string, width?: number) =>
-        renderSparkline(parseSeries(series), width),
-      argTypes: ["string", "int"],
-    },
-  };
-}
-
-// [LAW:one-source-of-truth] Domain value formatters. What remains after the
-// formatting-as-data epic (bdi) are primitives with NO template-native
-// expression — the bdi migration is complete. Do NOT migrate these to DSL
-// helpers; each one is retained for a load-bearing reason:
-//
-//   minutesUntilReset — returns a NUMBER for comparisons and arithmetic
-//     (`le (minutesUntilReset .x) 8`). A template helper writes to output
-//     and cannot return a value, so a helper form would duplicate the formula
-//     across every comparison site [LAW:one-source-of-truth].
-//
-//   formatInteger — locale-aware grouping via toLocaleString(). A regex
-//     helper would be locale-blind (always comma+3), a second divergent
-//     producer [LAW:one-source-of-truth]. The daemon inherits shell LANG/LC_*
-//     from the Rust spawner so grouping honors the user's locale at runtime.
-//
-//   round — Math.round (half-away-from-zero) consumed in `{{ round .pct }}%`
-//     segments. shadows sprigMath's precision-aware round intentionally:
-//     block/weekly/context need integer-rounding, not decimal rounding.
-//
-//   formatModelName / shortenModelName — regex parsing of external model IDs
-//     (named capture groups, version assembly, variant stripping). Trust-
-//     boundary normalization, not display policy. No regex primitive in DSL.
-//
-// The display-formatting families moved to DSL helpers in DEFAULT_DSL_CONFIG:
-// cost/token/budget (bdi.3), duration/time-remaining (bdi.4).
-//
-// [LAW:single-enforcer] minutesUntilReset reads "now" from the injected
-// `clock` — the SAME seam createCcCandybarEngine threads to sprigDatetime
-// (now/unixEpoch) and createEngine. One clock governs every time-dependent
-// evaluation; tests inject a frozen clock for determinism.
-export function formatterFuncs(clock: () => Date = () => new Date()): FuncMap {
-  return {
-    // Epoch-seconds → whole minutes until that instant, clamped at 0 for a past
-    // expiry: round(max(0, epoch*1000 − now)/60000). Consumed by the block/weekly
-    // segments (`formatLongTimeRemaining (minutesUntilReset .resetsAt)`) and the
-    // cacheTimer warmth countdown (numeric `le` thresholds).
-    minutesUntilReset: {
-      fn: (epochSeconds: number) =>
-        Math.round(
-          Math.max(0, epochSeconds * 1000 - clock().getTime()) / 60000,
-        ),
-      // [LAW:types-are-the-program] An epoch is integer-valued; `int` rejects a
-      // fractional or precision-losing carrier at the gate.
-      argTypes: ["int"],
-    },
-
-    // ─── Locale-grouped integer (context's "50,000") ──────────────────
-    // [LAW:one-source-of-truth] bdi.5: deliberately RETAINED as a primitive
-    // (not migrated to a DSL helper). toLocaleString reads the host locale the
-    // daemon inherits, so grouping is locale-correct (en_US "50,000" /
-    // de_DE "50.000"). A regex helper would be a second, locale-blind producer
-    // of grouping policy — same parsing/formatting boundary that keeps
-    // formatModelName here.
-    formatInteger: {
-      fn: (n: number) => formatInteger(n),
-      // [LAW:types-are-the-program] Integer grouping is meaningful only for an
-      // integer; `int` rejects a fractional/precision-losing carrier at the gate.
-      argTypes: ["int"],
-    },
-
-    // ─── Numeric helper (block/weekly's Math.round of pct) ────────────
-    // [LAW:one-source-of-truth] Math.round is a JS built-in shared between
-    // legacy and DSL — no wrapper indirection makes sense for it. The
-    // formatters.ts module documents domain-meaningful rules; rounding is
-    // not domain-meaningful, so it stays here.
-    round: {
-      fn: (n: number) => Math.round(n),
-      // [LAW:types-are-the-program] round takes a fractional value (e.g. a
-      // percentage) → `float` admits any finite number.
-      argTypes: ["float"],
-    },
-
-    // ─── Model-name normalizers (chunk-7 model dsl-pending → dsl-parity) ─
-    // [LAW:one-source-of-truth] formatModelName / shortenModelName are regex-
-    // based normalizers; the DSL function set has no regex primitive, so the
-    // only honest way to express them is to wrap the canonical impls. The
-    // model binding can then move from "echo display_name verbatim" (only
-    // byte-parity for friendly names) to "echo normalized model name" (full
-    // behavioral parity, including raw IDs like "claude-sonnet-4-6").
-    formatModelName: {
-      fn: (raw: string) => formatModelName(raw),
-      argTypes: ["string"],
-    },
-    shortenModelName: {
-      fn: (formatted: string) => shortenModelName(formatted),
-      argTypes: ["string"],
-    },
-  };
-}

package/src/template-engine/index.ts

@@ -1,11 +0,0 @@
-export { createCcCandybarEngine } from "./engine.js";
-export { buildScope } from "./scope.js";
-export { ccCandybarFuncs } from "./funcs.js";
-export { fragmentsToCells } from "./cells.js";
-export { evaluateWhen, applySegmentLayout } from "./layout.js";
-export type {
-  SegmentLayoutOptions,
-  JustifyMode,
-  TruncateMode,
-} from "./layout.js";
-export { resolveSegmentColors, ColorSpecError } from "./colors.js";