@promptctl/cc-candybar 1.0.0

package/src/utils/color-support.ts

@@ -0,0 +1,118 @@
+import process from "node:process";
+import tty from "node:tty";
+
+export function getColorSupport(): "none" | "ansi" | "ansi256" | "truecolor" {
+  const { env } = process;
+
+  let colorEnabled = true;
+
+  if (env.NO_COLOR && env.NO_COLOR !== "") {
+    colorEnabled = false;
+  }
+
+  const forceColor = env.FORCE_COLOR;
+  if (forceColor && forceColor !== "") {
+    if (forceColor === "false" || forceColor === "0") {
+      return "none";
+    }
+    if (forceColor === "true" || forceColor === "1") {
+      return "ansi";
+    }
+    if (forceColor === "2") {
+      return "ansi256";
+    }
+    if (forceColor === "3") {
+      return "truecolor";
+    }
+    return "ansi";
+  }
+
+  if (!colorEnabled) {
+    return "none";
+  }
+
+  if (env.TERM === "dumb") {
+    return "none";
+  }
+
+  if (env.CI) {
+    if (
+      ["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)
+    ) {
+      return "truecolor";
+    }
+    return "ansi";
+  }
+
+  if (env.COLORTERM === "truecolor") {
+    return "truecolor";
+  }
+
+  const truecolorTerminals = [
+    "xterm-kitty",
+    "xterm-ghostty",
+    "wezterm",
+    "alacritty",
+    "foot",
+    "contour",
+  ];
+
+  if (truecolorTerminals.includes(env.TERM || "")) {
+    return "truecolor";
+  }
+
+  if (env.TERM_PROGRAM) {
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app":
+        return "truecolor";
+      case "Apple_Terminal":
+        return "ansi256";
+      case "vscode":
+        return "truecolor";
+      case "Tabby":
+        return "truecolor";
+    }
+  }
+
+  if (/-256(color)?$/i.test(env.TERM || "")) {
+    return "ansi256";
+  }
+
+  if (/-truecolor$/i.test(env.TERM || "")) {
+    return "truecolor";
+  }
+
+  if (
+    /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(
+      env.TERM || "",
+    )
+  ) {
+    return "ansi";
+  }
+
+  if (env.COLORTERM) {
+    return "ansi";
+  }
+
+  if (tty?.WriteStream?.prototype?.hasColors) {
+    try {
+      const colors = tty.WriteStream.prototype.hasColors();
+      if (!colors) {
+        return "none";
+      }
+
+      const has256Colors = tty.WriteStream.prototype.hasColors(256);
+      const has16mColors = tty.WriteStream.prototype.hasColors(16777216);
+
+      if (has16mColors) {
+        return "truecolor";
+      } else if (has256Colors) {
+        return "ansi256";
+      } else {
+        return "ansi";
+      }
+    } catch {}
+  }
+
+  return "ansi";
+}

package/src/utils/formatters.ts

@@ -0,0 +1,77 @@
+const CLAUDE_MODEL_PATTERN =
+  /^(?:(?:global|apac|au|eu|us|us-east-\d|us-west-\d|eu-west-\d|eu-central-\d)\.)?(?:anthropic\.|azure_ai\/|bedrock\/|vertex_ai\/)?claude-(?:(?<family>opus|sonnet|haiku)-(?<newMajor>\d+)(?:-(?<newMinor>\d))?|(?<oldMajor>\d+)(?:-(?<oldMinor>\d))?-(?<oldFamily>opus|sonnet|haiku))(?:[-@]\d{8})?(?:-v\d+:\d+)?(?:-latest)?$/i;
+
+const FRIENDLY_MODEL_PATTERN =
+  /^(?<family>opus|sonnet|haiku)\s+(?<major>\d+)(?:\.(?<minor>\d))?$/i;
+
+export function formatModelName(rawName: string): string {
+  if (!rawName) {
+    return "Claude";
+  }
+
+  // [LAW:one-source-of-truth] strip variant decorations (e.g. " (1M context)",
+  // "[1m]") so all callers see canonical "Family X.Y" output regardless of
+  // whether the input came from model.id or model.display_name.
+  const stripped = rawName
+    .trim()
+    .replace(/\s*\([^)]*\)\s*$/, "")
+    .replace(/\s*\[[^\]]*\]\s*$/, "")
+    .trim();
+
+  const match = stripped.match(CLAUDE_MODEL_PATTERN);
+  if (match?.groups) {
+    const { family, newMajor, newMinor, oldMajor, oldMinor, oldFamily } =
+      match.groups;
+
+    const modelFamily = family || oldFamily;
+    const major = newMajor || oldMajor;
+    const minor = newMinor || oldMinor;
+
+    if (modelFamily && major) {
+      const capitalizedFamily =
+        modelFamily.charAt(0).toUpperCase() +
+        modelFamily.slice(1).toLowerCase();
+      const version = minor ? `${major}.${minor}` : major;
+      return `${capitalizedFamily} ${version}`;
+    }
+  }
+
+  const friendly = stripped.match(FRIENDLY_MODEL_PATTERN);
+  if (friendly?.groups) {
+    const family = friendly.groups.family!;
+    const major = friendly.groups.major!;
+    const minor = friendly.groups.minor;
+    const capitalizedFamily =
+      family.charAt(0).toUpperCase() + family.slice(1).toLowerCase();
+    const version = minor ? `${major}.${minor}` : major;
+    return `${capitalizedFamily} ${version}`;
+  }
+
+  return stripped || rawName;
+}
+
+export function shortenModelName(formatted: string): string {
+  // [LAW:one-type-per-behavior] same parser, different rendering — operates on
+  // the canonical output of formatModelName so callers don't reparse raw IDs.
+  const match = formatted.match(FRIENDLY_MODEL_PATTERN);
+  if (!match?.groups) return formatted;
+  const family = match.groups.family!;
+  const major = match.groups.major!;
+  const minor = match.groups.minor;
+  const initial = family.charAt(0).toUpperCase();
+  const version = minor ? `${major}.${minor}` : major;
+  return `${initial}${version}`;
+}
+
+// [LAW:one-source-of-truth] Locale-grouped integer rendering. Callers that
+// want "50,000" instead of "50000" go through this rather than calling
+// toLocaleString() ad-hoc — the legacy context segment used the latter
+// pattern inline, and the DSL formatter (template-engine/funcs.ts)
+// delegates here so the two producers agree by construction.
+//
+// No locale argument: the default-locale behaviour is exactly what the
+// legacy renderer did (`n.toLocaleString()`), so byte-parity holds with
+// whatever locale the host process picks at startup.
+export function formatInteger(n: number): string {
+  return n.toLocaleString();
+}

package/src/utils/logger.ts

@@ -0,0 +1,5 @@
+export function debug(message: string, ...args: unknown[]): void {
+  if (process.env.CC_CANDYBAR_DEBUG) {
+    console.error(`[DEBUG] ${message}`, ...args);
+  }
+}

package/src/utils/outcome.ts

@@ -0,0 +1,33 @@
+// [LAW:types-are-the-program] The provider-outcome vocabulary: a data fetch
+// either produced a value, found that the domain genuinely has none (no
+// upstream configured, no transcript yet), or failed to get an answer at all
+// (timeout, spawn error, unreadable file). Before this type, the third state
+// was unrepresentable — failure had to wear a real value's clothes (0, "",
+// a basename) and the lie flowed all the way to the rendered bar.
+//
+// [LAW:dataflow-not-control-flow] Failure is a value that flows to a
+// boundary, not a swallowed branch. Producers classify once, where the
+// command semantics are known; consumers fold once, at the edge where the
+// log effect and the payload mapping live.
+export type Outcome<T> =
+  | { readonly kind: "ok"; readonly value: T }
+  | { readonly kind: "absent" }
+  | { readonly kind: "failed"; readonly reason: string };
+
+export function ok<T>(value: T): Outcome<T> {
+  return { kind: "ok", value };
+}
+
+export const ABSENT: Outcome<never> = { kind: "absent" };
+
+export function failed(reason: string): Outcome<never> {
+  return { kind: "failed", reason };
+}
+
+// [LAW:dataflow-not-control-flow] Total fold for consumers that only need a
+// value-or-fallback view (e.g. var-system's typed projection). Both non-ok
+// arms collapse to the fallback; consumers that must distinguish absent from
+// failed (the logging boundaries) match on `kind` instead.
+export function orElse<T>(outcome: Outcome<T> | undefined, fallback: T): T {
+  return outcome?.kind === "ok" ? outcome.value : fallback;
+}

package/src/utils/schema-validator.ts

@@ -0,0 +1,126 @@
+// [LAW:single-enforcer] All hookData schema validation flows through
+// validateHookData. One trust boundary, one check.
+//
+// [LAW:dataflow-not-control-flow] Every check runs unconditionally. Results
+// accumulate into a ValidationReport — callers decide what to do with them.
+// No early exits, no control-flow branches that skip checks.
+
+import type { ClaudeHookData } from "./claude";
+
+export interface ValidationReport {
+  // Required fields that were absent or had wrong types.
+  missingRequired: string[];
+  typeMismatches: Array<{ path: string; expected: string; got: string }>;
+  // Top-level keys not in the known schema — Anthropic may have added new fields.
+  unknownTopLevelFields: string[];
+}
+
+// Top-level keys Anthropic sends (plus hook_event_name, which cc-candybar adds).
+// Adding a new Anthropic field here suppresses the "unknown field" log for it.
+const KNOWN_TOP_LEVEL = new Set([
+  "hook_event_name", // cc-candybar internal
+  "session_id",
+  "session_name",
+  "transcript_path",
+  "cwd",
+  "model",
+  "workspace",
+  "version",
+  "output_style",
+  "cost",
+  "context_window",
+  "exceeds_200k_tokens",
+  "effort",
+  "thinking",
+  "rate_limits",
+  "vim",
+  "agent",
+  "worktree",
+]);
+
+// Required fields: [dot-separated path, expected typeof result]
+// "object" means non-null, non-array object. Checked in declaration order.
+const REQUIRED_FIELDS: Array<
+  [string, "string" | "number" | "boolean" | "object"]
+> = [
+  ["session_id", "string"],
+  ["transcript_path", "string"],
+  ["cwd", "string"],
+  ["model", "object"],
+  ["model.id", "string"],
+  ["model.display_name", "string"],
+  ["workspace", "object"],
+  ["workspace.current_dir", "string"],
+  ["workspace.project_dir", "string"],
+];
+
+/**
+ * Validate raw hookData received over the wire against the known Anthropic schema.
+ *
+ * Returns the data typed as ClaudeHookData alongside a ValidationReport.
+ * Never throws — divergences are reported, not thrown. The daemon decides
+ * how to surface them (dlog warn/info).
+ *
+ * [LAW:no-defensive-null-guards] Validation at the trust boundary is correct.
+ * Everywhere else in the codebase, hookData fields are used without guards
+ * because this boundary guarantees their presence.
+ */
+export function validateHookData(raw: unknown): {
+  data: ClaudeHookData;
+  report: ValidationReport;
+} {
+  const report: ValidationReport = {
+    missingRequired: [],
+    typeMismatches: [],
+    unknownTopLevelFields: [],
+  };
+
+  const obj: Record<string, unknown> =
+    raw !== null && typeof raw === "object" && !Array.isArray(raw)
+      ? (raw as Record<string, unknown>)
+      : {};
+
+  for (const [path, expectedType] of REQUIRED_FIELDS) {
+    const value = resolvePath(obj, path);
+    if (value === undefined || value === null) {
+      report.missingRequired.push(path);
+    } else {
+      const actualType = Array.isArray(value) ? "array" : typeof value;
+      const mismatch =
+        expectedType === "object"
+          ? actualType !== "object"
+          : actualType !== expectedType;
+      if (mismatch) {
+        report.typeMismatches.push({
+          path,
+          expected: expectedType,
+          got: actualType,
+        });
+      }
+    }
+  }
+
+  for (const key of Object.keys(obj)) {
+    if (!KNOWN_TOP_LEVEL.has(key)) {
+      report.unknownTopLevelFields.push(key);
+    }
+  }
+
+  return { data: raw as ClaudeHookData, report };
+}
+
+function resolvePath(obj: Record<string, unknown>, dotPath: string): unknown {
+  let cur: unknown = obj;
+  for (const key of dotPath.split(".")) {
+    if (
+      cur === null ||
+      cur === undefined ||
+      typeof cur !== "object" ||
+      Array.isArray(cur)
+    ) {
+      return undefined;
+    }
+    cur = (cur as Record<string, unknown>)[key];
+  }
+  return cur;
+}

package/src/utils/single-flight.ts

@@ -0,0 +1,57 @@
+// [LAW:one-source-of-truth] A keyed in-flight coalescer: while a computation
+// for a given key is running, every concurrent caller for that same key shares
+// the ONE in-flight promise instead of starting its own. The fs gate
+// (transcript-fs.ts) bounds how many fs ops run at once; it does NOT dedupe the
+// work — K concurrent renders each still launch their own (now-bounded)
+// whole-tree scan. This is the missing piece: K renders trigger ONE scan, not
+// K. The gate makes that one scan's cost bounded; this makes there be one.
+//
+// [LAW:types-are-the-program] Coalescing is expressed by ROUTING through one
+// owner of "is this key already computing", not by a guard scattered at each
+// callsite. The selection is dataflow — `inflight.get(key) ?? start(...)` —
+// both arms yield a `Promise<T>`, so the operation (return the shared promise)
+// always runs; only the value varies. There is no `if (alreadyRunning) return`
+// branch that skips work.
+//
+// Scope of sharing is exactly the in-flight WINDOW: the entry is removed when
+// the promise settles (success OR failure), so this is a coalescer, never a
+// cache. A fresh call after completion starts a new computation — staleness is
+// impossible because nothing is retained past settle. Result caching, when
+// wanted, is a separate concern owned by the caller (the disk/LRU caches).
+//
+// This also dissolves the render-timeout orphaning problem
+// (brandon-daemon-memory-leak-gn4.3): a render that abandons its await (the
+// daemon's 200ms response timeout fires) does not cancel or duplicate the
+// shared computation — there is only ever one scan in flight per key, so the
+// timed-out render leaves behind the single canonical computation that the next
+// render coalesces onto. A timeout therefore adds zero new fs work.
+export class SingleFlight {
+  private readonly inflight = new Map<string, Promise<unknown>>();
+
+  run<T>(key: string, factory: () => Promise<T>): Promise<T> {
+    return (
+      (this.inflight.get(key) as Promise<T> | undefined) ??
+      this.start(key, factory)
+    );
+  }
+
+  private start<T>(key: string, factory: () => Promise<T>): Promise<T> {
+    const promise = factory();
+    this.inflight.set(key, promise);
+    // Deregister on settle. The identity check guards the (impossible-by-key
+    // but cheap-to-prove) case where a newer promise has replaced this one:
+    // only the promise that registered itself clears itself.
+    const deregister = (): void => {
+      if (this.inflight.get(key) === promise) this.inflight.delete(key);
+    };
+    promise.then(deregister, deregister);
+    return promise;
+  }
+
+  // Number of computations currently in flight — a read-only observability
+  // surface for tests asserting the coalescing contract (one in-flight entry
+  // per key). Never read as control flow.
+  get size(): number {
+    return this.inflight.size;
+  }
+}

package/src/utils/terminal-width.ts

@@ -0,0 +1,43 @@
+// [LAW:single-enforcer] Terminal width has exactly one authoritative source:
+// the live client's shell context (env / ioctl), captured at the wire boundary
+// and threaded through as request data. This module is a pure resolver from
+// (caller-supplied hint, ambient env, stderr TTY) to "width with reserve
+// applied, or null." Subprocess-based fallbacks belong at the wire boundary,
+// not here. stderr (not stdout) is the TTY-side fallback: when this resolver
+// runs in a hook context, stdout is the captured statusline pipe while stderr
+// stays attached to the parent terminal.
+//
+// [LAW:dataflow-not-control-flow] The function always runs the same code path.
+// Variability lives in the inputs (hint set or not, env set or not, stderr a
+// TTY or not), never in whether work runs.
+
+// @info Reserves characters for Claude Code's right-side UI messages
+// (e.g., "Current: 2.1.78 · latest: 2.1.78", "Thinking off")
+const RESERVED_CHARS = 45;
+
+// [LAW:single-enforcer] The canonical raw-cols → usable-cols transform.
+// Every consumer that needs to honor Claude Code's overlay routes through
+// here; there is no parallel `cols - 45` math anywhere. Exposed so callers
+// that already have a raw width (e.g. the daemon's wire-fallback path,
+// the demo reading process.stdout.columns) can apply the reserve without
+// re-entering the env/stderr resolution chain in getTerminalWidth.
+export function applyClaudeCodeReserve(rawCols: number): number {
+  return Math.max(1, rawCols - RESERVED_CHARS);
+}
+
+export function getTerminalWidth(termColsHint?: number): number | null {
+  if (termColsHint && termColsHint > 0)
+    return applyClaudeCodeReserve(termColsHint);
+
+  const envColumns = process.env.COLUMNS;
+  if (envColumns) {
+    const parsed = parseInt(envColumns, 10);
+    if (!isNaN(parsed) && parsed > 0) return applyClaudeCodeReserve(parsed);
+  }
+
+  if (process.stderr.columns && process.stderr.columns > 0) {
+    return applyClaudeCodeReserve(process.stderr.columns);
+  }
+
+  return null;
+}

package/src/utils/terminal.ts

@@ -0,0 +1,11 @@
+export const ESC = String.fromCharCode(27);
+const ANSI_REGEX = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
+export const ANSI_SPLIT = new RegExp(`(${ESC}\\[[0-9;]*m)`);
+
+export function stripAnsi(str: string): string {
+  return str.replace(ANSI_REGEX, "");
+}
+
+export function visibleLength(str: string): number {
+  return stripAnsi(str).length;
+}

package/src/utils/transcript-fs.ts

@@ -0,0 +1,162 @@
+import {
+  open as fsOpen,
+  readdir as fsReaddir,
+  readFile as fsReadFile,
+  stat as fsStat,
+} from "node:fs/promises";
+import type { FileHandle } from "node:fs/promises";
+
+import { ABSENT, failed, ok, type Outcome } from "./outcome";
+
+// [LAW:single-enforcer] One owner of the transcript-scanning in-flight-I/O
+// budget. Every readdir/stat/readFile over the ~/.claude/projects tree passes
+// through this module's limiter, so the number of concurrent libuv fs requests
+// is bounded by a constant no matter how many renders fan out at once. The OOM
+// heap proved the illegal state this forbids: ~3046 FSReqPromise pending at
+// once, each pinning a parked await-stack.
+//
+// [LAW:types-are-the-program] The bound is enforced by ROUTING, not by a
+// post-hoc guard: the transcript path imports these gated primitives instead of
+// node:fs/promises, so "thousands of stats/reads in flight" is unrepresentable
+// rather than merely checked. There is no `if (tooMany)` anywhere — the same
+// fan-out runs every render; the limiter only decides *when* each op dispatches.
+
+// 8 = 2× the libuv default UV_THREADPOOL_SIZE (4). Two dispatched ops per worker
+// keeps every threadpool thread fed without a queue-drain stall between syscalls,
+// while peak in-flight memory stays O(threadpool) rather than O(transcript count).
+const TRANSCRIPT_FS_CONCURRENCY = 8;
+
+interface Waiter {
+  readonly wake: () => void;
+  next: Waiter | null;
+}
+
+// A counting semaphore that runs at most `max` thunks concurrently. Slots are
+// handed off directly to the next waiter on release (never incremented while a
+// waiter is parked), so admission can never exceed `max` — the over-admission
+// race of an increment-then-wake design is structurally absent.
+class Limiter {
+  private slots: number;
+  // FIFO wait queue as a singly-linked list: enqueue at `tail`, dequeue at
+  // `head`, both O(1) with no array reindexing (Array.shift would be O(n), so a
+  // drain of the thousands-of-queued-ops burst this limiter exists to absorb
+  // would be O(n²) on the render hot path). A dequeued node is immediately
+  // unreferenced, so a continuously-saturated queue retains only the waiters
+  // currently parked — no consumed-prefix accumulates, unlike a head-index
+  // array that only reclaims on full drain.
+  private head: Waiter | null = null;
+  private tail: Waiter | null = null;
+
+  constructor(max: number) {
+    this.slots = max;
+  }
+
+  async run<T>(task: () => Promise<T>): Promise<T> {
+    await this.acquire();
+    try {
+      return await task();
+    } finally {
+      this.release();
+    }
+  }
+
+  private async acquire(): Promise<void> {
+    if (this.slots > 0) {
+      this.slots--;
+      return;
+    }
+    // No slot free — park until release() hands one to us. The slot is
+    // transferred directly, so we must NOT decrement again on resume.
+    await new Promise<void>((wake) => {
+      const node: Waiter = { wake, next: null };
+      if (this.tail) this.tail.next = node;
+      else this.head = node;
+      this.tail = node;
+    });
+  }
+
+  private release(): void {
+    const node = this.head;
+    if (!node) {
+      // No one waiting — return the slot to the pool.
+      this.slots++;
+      return;
+    }
+    // Hand the slot directly to the next waiter; the dequeued node is dropped.
+    this.head = node.next;
+    if (!this.head) this.tail = null;
+    node.wake();
+  }
+}
+
+const gate = new Limiter(TRANSCRIPT_FS_CONCURRENCY);
+
+// Wrap an async fs primitive so every call flows through the shared gate. The
+// `(...args: never[])` bound is the maximally-permissive function constraint
+// (parameters are contravariant, so `never[]` accepts any arg list) — it admits
+// every fs/promises overload, not rejects them. Callers see the original
+// overloaded type `F`; the cast is needed because TS can't prove a generic
+// wrapper preserves an overload set, but each fs overload is a valid `fn(...)`
+// call, so the wrap is sound (verified: `tsc --noEmit` passes against the
+// multi-overload call sites in claude.ts/cache.ts).
+function gated<F extends (...args: never[]) => Promise<unknown>>(fn: F): F {
+  return ((...args: Parameters<F>) =>
+    gate.run(() => fn(...args))) as unknown as F;
+}
+
+export const readdir = gated(fsReaddir);
+export const readFile = gated(fsReadFile);
+export const stat = gated(fsStat);
+
+// [LAW:single-enforcer] A bounded tail read through the SAME gate: the last
+// `maxBytes` of a file (the whole file when smaller), plus whether that window
+// reaches the file start. The open→stat→read→close runs under one gate slot, so
+// a tail read counts as one in-flight op exactly like a readFile — a transcript
+// scanner that grows its window backward must use THIS, not raw node:fs, or it
+// reintroduces the unbounded-fs state the gate forbids.
+//
+// [LAW:no-silent-failure] The file not existing is the expected, every-render
+// case for a fresh session (no transcript yet) — `absent`. Any other error
+// (permissions, I/O) is a real read failure — `failed`, carrying its reason
+// to whichever boundary owns the log effect. Folding both into one null made
+// a broken transcript indistinguishable from a missing one.
+export async function readTail(
+  path: string,
+  maxBytes: number,
+): Promise<Outcome<{ buf: Buffer; fromStart: boolean }>> {
+  return gate.run(async () => {
+    let fh: FileHandle | null = null;
+    try {
+      fh = await fsOpen(path, "r");
+      const { size } = await fh.stat();
+      const start = Math.max(0, size - maxBytes);
+      const buf = Buffer.alloc(size - start);
+      // [LAW:no-silent-fallbacks] A single read may return short — the scanner
+      // would then parse a zero-padded tail and miss cache activity. Loop until
+      // the window is filled or EOF; on a short final read (the file shrank
+      // under us) return only the bytes actually read, never the zero padding.
+      let off = 0;
+      while (off < buf.length) {
+        const { bytesRead } = await fh.read(
+          buf,
+          off,
+          buf.length - off,
+          start + off,
+        );
+        if (bytesRead === 0) break;
+        off += bytesRead;
+      }
+      return ok({
+        buf: off === buf.length ? buf : buf.subarray(0, off),
+        fromStart: start === 0,
+      });
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException).code === "ENOENT") return ABSENT;
+      return failed(
+        `readTail ${path}: ${e instanceof Error ? e.message : String(e)}`,
+      );
+    } finally {
+      await fh?.close();
+    }
+  });
+}

package/src/var-system/index.ts

@@ -0,0 +1,24 @@
+export { VariableStore, type VarNode } from "./store";
+export {
+  type VarType,
+  type VarValue,
+  typeOf,
+  toString,
+  toNumber,
+  toBool,
+} from "./types";
+export {
+  SourceRegistry,
+  parseDuration,
+  formatGoTime,
+  MIN_SHELL_TTL_MS,
+  type CachePolicy,
+  type ShellOptions,
+  type FileOptions,
+  type TemplateOptions,
+  type TimeOptions,
+  type GitField,
+  type GitOptions,
+  type StateOptions,
+  type LastError,
+} from "./sources";