@herbertgao/pi-extensions 2026.9.19 → 2026.10.0

package/node_modules/pi-footer/src/cache.ts

@@ -1,106 +0,0 @@
-export const CACHE_NAMESPACES = { runtime: "runtime", git: "git" } as const;
-type CacheNamespace = (typeof CACHE_NAMESPACES)[keyof typeof CACHE_NAMESPACES];
-
-interface CacheEntry<V> {
-  value: V | null;
-  updatedAt: number | null;
-  pending: Promise<void> | null;
-  listeners: Set<() => void>;
-}
-
-export class AsyncCache {
-  private readonly entries = new Map<string, CacheEntry<unknown>>();
-  private readonly maxEntries: number;
-  private readonly now: () => number;
-
-  constructor(maxEntries = 200, now: () => number = () => Date.now()) {
-    this.maxEntries = maxEntries;
-    this.now = now;
-  }
-
-  get<K, V, F>(
-    ns: CacheNamespace,
-    key: K,
-    ttlMs: number,
-    filter: F,
-    fetcher: (filter: F) => Promise<V | null>,
-    onRefresh?: () => void,
-  ): V | null {
-    const cacheKey = this.cacheKey(ns, key);
-    const entry = this.entryFor<V>(cacheKey);
-    if (this.isFresh(entry, ttlMs)) return entry.value;
-
-    this.addListener(entry, onRefresh);
-    if (!entry.pending) entry.pending = this.refresh(entry, filter, fetcher);
-
-    return entry.value;
-  }
-
-  clear(): void {
-    this.entries.clear();
-  }
-
-  private entryFor<V>(cacheKey: string): CacheEntry<V> {
-    const cached = this.entries.get(cacheKey);
-    if (cached) return cached as CacheEntry<V>;
-
-    const entry: CacheEntry<V> = {
-      value: null,
-      updatedAt: null,
-      pending: null,
-      listeners: new Set(),
-    };
-    this.entries.set(cacheKey, entry as CacheEntry<unknown>);
-    this.evictOldestEntry();
-    return entry;
-  }
-
-  private isFresh<V>(entry: CacheEntry<V>, ttlMs: number): boolean {
-    return entry.updatedAt !== null && this.now() - entry.updatedAt < ttlMs;
-  }
-
-  private addListener<V>(entry: CacheEntry<V>, listener: (() => void) | undefined): void {
-    if (listener) entry.listeners.add(listener);
-  }
-
-  private async refresh<V, F>(
-    entry: CacheEntry<V>,
-    filter: F,
-    fetcher: (filter: F) => Promise<V | null>,
-  ): Promise<void> {
-    try {
-      entry.value = await fetcher(filter);
-    } catch {
-      entry.value = null;
-    } finally {
-      entry.updatedAt = this.now();
-      entry.pending = null;
-      this.notify(entry);
-    }
-  }
-
-  private notify<V>(entry: CacheEntry<V>): void {
-    const listeners = [...entry.listeners];
-    entry.listeners.clear();
-
-    for (const listener of listeners) {
-      try {
-        listener();
-      } catch {
-        // Cache refresh notifications are best-effort.
-      }
-    }
-  }
-
-  private evictOldestEntry(): void {
-    if (this.entries.size <= this.maxEntries) return;
-    const oldestKey = this.entries.keys().next().value;
-    if (oldestKey !== undefined) this.entries.delete(oldestKey);
-  }
-
-  private cacheKey<K>(ns: CacheNamespace, key: K): string {
-    return `${ns}:${String(key)}`;
-  }
-}
-
-export const asyncCache = new AsyncCache();

package/node_modules/pi-footer/src/colors.ts

@@ -1,237 +0,0 @@
-import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
-import { Chalk } from "chalk";
-
-const chalk = {
-  level: 2,
-  c: new Chalk({ level: 2 }),
-};
-
-export const COLOR_LEVEL_VALUES = ["truecolor", "ansi256", "ansi16", "none"] as const;
-
-export type ColorLevel = (typeof COLOR_LEVEL_VALUES)[number];
-export type ColorName =
-  | "default"
-  | "black"
-  | "red"
-  | "green"
-  | "yellow"
-  | "blue"
-  | "magenta"
-  | "cyan"
-  | "white"
-  | "brightBlack"
-  | "brightRed"
-  | "brightGreen"
-  | "brightYellow"
-  | "brightBlue"
-  | "brightMagenta"
-  | "brightCyan"
-  | "brightWhite"
-  | `ansi256:${number}`
-  | `pi:${ThemeColor}`;
-
-interface ColorChoice {
-  label: string;
-  value: ColorName;
-}
-
-export const STANDARD_COLORS: ColorChoice[] = [
-  { label: "Default", value: "default" },
-  { label: "Black", value: "black" },
-  { label: "Red", value: "red" },
-  { label: "Green", value: "green" },
-  { label: "Yellow", value: "yellow" },
-  { label: "Blue", value: "blue" },
-  { label: "Magenta", value: "magenta" },
-  { label: "Cyan", value: "cyan" },
-  { label: "White", value: "white" },
-  { label: "Bright Black", value: "brightBlack" },
-  { label: "Bright Red", value: "brightRed" },
-  { label: "Bright Green", value: "brightGreen" },
-  { label: "Bright Yellow", value: "brightYellow" },
-  { label: "Bright Blue", value: "brightBlue" },
-  { label: "Bright Magenta", value: "brightMagenta" },
-  { label: "Bright Cyan", value: "brightCyan" },
-  { label: "Bright White", value: "brightWhite" },
-];
-
-const PI_THEME_COLORS: ThemeColor[] = [
-  "accent",
-  "border",
-  "borderAccent",
-  "borderMuted",
-  "success",
-  "error",
-  "warning",
-  "muted",
-  "dim",
-  "text",
-  "thinkingText",
-  "userMessageText",
-  "customMessageText",
-  "customMessageLabel",
-  "toolTitle",
-  "toolOutput",
-  "toolDiffAdded",
-  "toolDiffRemoved",
-  "toolDiffContext",
-  "syntaxType",
-  "thinkingOff",
-  "thinkingMinimal",
-  "thinkingLow",
-  "thinkingMedium",
-  "thinkingHigh",
-  "thinkingXhigh",
-  "bashMode",
-];
-
-const PI_FOREGROUND_COLORS: ColorChoice[] = PI_THEME_COLORS.map((color) => ({
-  label: `Pi ${themeColorDisplayName(color)}`,
-  value: `pi:${color}`,
-}));
-
-export const FOREGROUND_COLORS: ColorChoice[] = [...STANDARD_COLORS, ...PI_FOREGROUND_COLORS];
-
-const ANSI16_FG: Record<
-  Exclude<ColorName, `ansi256:${number}` | `pi:${ThemeColor}`>,
-  [number, number]
-> = {
-  default: [39, 49],
-  black: [30, 40],
-  red: [31, 41],
-  green: [32, 42],
-  yellow: [33, 43],
-  blue: [34, 44],
-  magenta: [35, 45],
-  cyan: [36, 46],
-  white: [37, 47],
-  brightBlack: [90, 100],
-  brightRed: [91, 101],
-  brightGreen: [92, 102],
-  brightYellow: [93, 103],
-  brightBlue: [94, 104],
-  brightMagenta: [95, 105],
-  brightCyan: [96, 106],
-  brightWhite: [97, 107],
-};
-
-export function normalizeColor(value: unknown): ColorName | undefined {
-  if (typeof value !== "string") return undefined;
-  if (STANDARD_COLORS.some((color) => color.value === value)) return value as ColorName;
-  if (PI_FOREGROUND_COLORS.some((color) => color.value === value)) return value as ColorName;
-  const match = /^ansi256:([0-9]{1,3})$/.exec(value);
-  if (!match) return undefined;
-  const code = Number(match[1]);
-  return Number.isInteger(code) && code >= 0 && code <= 255
-    ? (`ansi256:${code}` as ColorName)
-    : undefined;
-}
-
-export function colorDisplayName(color: ColorName | undefined): string {
-  if (!color || color === "default") return "Default";
-  if (color.startsWith("ansi256:")) return `ANSI256 ${color.slice("ansi256:".length)}`;
-  if (color.startsWith("pi:"))
-    return PI_FOREGROUND_COLORS.find((entry) => entry.value === color)?.label ?? color;
-  return STANDARD_COLORS.find((entry) => entry.value === color)?.label ?? color;
-}
-
-export function ansi256Digits(color: ColorName | undefined): string {
-  return color?.startsWith("ansi256:") ? String(Number(color.slice("ansi256:".length))) : "0";
-}
-
-export function appendAnsi256Digit(color: ColorName | undefined, digit: string): ColorName {
-  const digits = ansi256Digits(color);
-  const next = Number(`${digits}${digit}`);
-  return `ansi256:${Math.min(255, next)}`;
-}
-
-export function deleteAnsi256Digit(color: ColorName | undefined): ColorName {
-  const digits = ansi256Digits(color) || "0";
-  const next = digits.slice(0, -1);
-  return `ansi256:${next === "" ? 0 : Number(next)}`;
-}
-
-function useColorLevel(level: ColorLevel) {
-  const next = level === "truecolor" ? 3 : level === "ansi256" ? 2 : 1;
-  if (chalk.level === next) return;
-  chalk.level = next;
-  chalk.c = new Chalk({ level: next });
-}
-
-export function applyColors(
-  text: string,
-  foreground: ColorName | undefined,
-  background: ColorName | undefined,
-  bold: boolean | undefined,
-  level: ColorLevel,
-  theme?: Theme,
-): string {
-  if (level === "none") return text;
-  useColorLevel(level);
-
-  let output = text;
-  if (foreground && foreground !== "default")
-    output = applyOne(output, foreground, false, level, theme);
-  if (background && background !== "default") output = applyOne(output, background, true, level);
-  if (bold) output = chalk.c.bold(output);
-  return output;
-}
-
-// The styleable color bag shared by widget options and the context conditional-color helper.
-// fg/bg are validated ColorName (color picker); the warning/danger quartet is raw text input
-// (kind: "text" properties) normalized via normalizeColor() at read time.
-export interface ConditionalColorFields {
-  fg?: ColorName;
-  bg?: ColorName;
-  warningFg?: string;
-  warningBg?: string;
-  dangerFg?: string;
-  dangerBg?: string;
-}
-
-export function resetAnsi256Colors<T extends ConditionalColorFields>(options: T): T {
-  const next = { ...options };
-  if (next.fg?.startsWith("ansi256:")) next.fg = "default";
-  if (next.bg?.startsWith("ansi256:")) next.bg = "default";
-  if (next.warningFg?.startsWith("ansi256:")) next.warningFg = "default";
-  if (next.warningBg?.startsWith("ansi256:")) next.warningBg = "default";
-  if (next.dangerFg?.startsWith("ansi256:")) next.dangerFg = "default";
-  if (next.dangerBg?.startsWith("ansi256:")) next.dangerBg = "default";
-  return next;
-}
-
-function themeColorDisplayName(color: ThemeColor): string {
-  return color.replace(/([A-Z])/g, " $1").replace(/^./, (char) => char.toUpperCase());
-}
-
-function applyOne(
-  text: string,
-  color: ColorName,
-  background: boolean,
-  level: ColorLevel,
-  theme?: Theme,
-): string {
-  if (color.startsWith("pi:")) {
-    if (background || !theme) return text;
-    return theme.fg(color.slice("pi:".length) as ThemeColor, text);
-  }
-  if (color.startsWith("ansi256:")) {
-    const code = Number(color.slice("ansi256:".length));
-    if (level === "ansi256" || level === "truecolor") {
-      return background ? chalk.c.bgAnsi256(code)(text) : chalk.c.ansi256(code)(text);
-    }
-    return text;
-  }
-
-  const codes = ANSI16_FG[color as Exclude<ColorName, `ansi256:${number}` | `pi:${ThemeColor}`>];
-  if (!codes || color === "default") return text;
-  return `\x1b[${background ? codes[1] : codes[0]}m${text}\x1b[${background ? 49 : 39}m`;
-}
-
-// Keep the escape byte out of a regex literal so oxlint's no-control-regex rule does not
-// flag the intentional ANSI matcher. RegExp still receives the ESC sequence at runtime.
-const ANSI_ESCAPE_PATTERN = new RegExp(String.raw`\x1B\[[0-?]*[ -/]*[@-~]`, "g");
-
-export function stripAnsi(text: string): string {
-  return text.replace(ANSI_ESCAPE_PATTERN, "");
-}

package/node_modules/pi-footer/src/config.ts

@@ -1,202 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-
-import type { ColorLevel } from "./colors.js";
-import { COLOR_LEVEL_VALUES, normalizeColor } from "./colors.js";
-import {
-  cloneExtensionStatusRow,
-  DEFAULT_EXTENSION_STATUS_ROW,
-  normalizeExtensionStatusRow,
-} from "./extension-statuses.js";
-import {
-  PRESET_DEFINITIONS,
-  type Preset,
-  type PresetDefinition,
-  type PresetWidget,
-} from "./presets.js";
-import { SEPARATOR_VALUES, type SeparatorStyle } from "./separators.js";
-import type {
-  IconMode,
-  StatuslineConfig,
-  StatuslineSettings,
-  TerminalOptions,
-  TerminalWidthMode,
-  WidgetEntry,
-} from "./types.js";
-import { ICON_MODE_VALUES, isRecord, TERMINAL_WIDTH_MODE_VALUES } from "./types.js";
-import { registry, type WidgetType } from "./widgets/registry.js";
-
-export const STATUS_KEY = "pi-footer";
-
-const CONFIG_ENV = "PI_FOOTER_CONFIG";
-const DEFAULT_CONFIG_PATH = join(getAgentDir(), "extensions", "pi-footer.json");
-const SEPARATORS = new Set<SeparatorStyle>(SEPARATOR_VALUES);
-
-const DEFAULT_TERMINAL_OPTIONS: TerminalOptions = {
-  widthMode: "full",
-  colorLevel: "ansi256",
-};
-
-export const DEFAULT_CONFIG: StatuslineConfig = {
-  version: 1,
-  enabled: true,
-  preset: "default",
-  lines: linesForPreset("default"),
-  separator: "dot",
-  separatorFg: "default",
-  separatorBg: "default",
-  iconMode: "emoji",
-  minimalist: false,
-  terminal: DEFAULT_TERMINAL_OPTIONS,
-  extensionStatusRow: DEFAULT_EXTENSION_STATUS_ROW,
-};
-
-export function getConfigPath(): string {
-  return process.env[CONFIG_ENV] ?? DEFAULT_CONFIG_PATH;
-}
-
-function linesForPreset(preset: Preset): WidgetEntry[][] {
-  return PRESET_DEFINITIONS[preset].lines.map((line) => widgetsFromPresetLine(line));
-}
-
-export function configWithPreset(config: StatuslineConfig, preset: Preset): StatuslineConfig {
-  const definition: PresetDefinition = PRESET_DEFINITIONS[preset];
-  return {
-    ...config,
-    preset,
-    lines: linesForPreset(preset),
-    separator: definition.separator ?? config.separator,
-    iconMode: definition.iconMode ?? config.iconMode,
-    terminal: { ...config.terminal, ...definition.terminal },
-  };
-}
-
-function widgetsFromPresetLine(line: readonly PresetWidget[]): WidgetEntry[] {
-  return line.map((widget) => registry.createEntry(widget.type, widget.options));
-}
-
-export function normalizeConfig(input: unknown): StatuslineConfig {
-  if (!isRecord(input)) return cloneConfig(DEFAULT_CONFIG);
-
-  const preset = isPreset(input.preset) ? input.preset : DEFAULT_CONFIG.preset;
-  const lines = normalizeLines(input.lines, preset);
-
-  return {
-    version: 1,
-    enabled: typeof input.enabled === "boolean" ? input.enabled : DEFAULT_CONFIG.enabled,
-    preset,
-    lines,
-    separator: isSeparatorStyle(input.separator)
-      ? input.separator
-      : (PRESET_DEFINITIONS[preset].separator ?? DEFAULT_CONFIG.separator),
-    separatorFg: normalizeColor(input.separatorFg) ?? DEFAULT_CONFIG.separatorFg,
-    separatorBg: normalizeColor(input.separatorBg) ?? DEFAULT_CONFIG.separatorBg,
-    iconMode: isIconMode(input.iconMode) ? input.iconMode : DEFAULT_CONFIG.iconMode,
-    minimalist:
-      typeof input.minimalist === "boolean" ? input.minimalist : DEFAULT_CONFIG.minimalist,
-    terminal: normalizeTerminalOptions(input.terminal, PRESET_DEFINITIONS[preset].terminal),
-    extensionStatusRow: normalizeExtensionStatusRow(input.extensionStatusRow),
-  };
-}
-
-export function cloneSettings(settings: StatuslineSettings): StatuslineSettings {
-  return {
-    ...settings,
-    terminal: { ...settings.terminal },
-    extensionStatusRow: cloneExtensionStatusRow(settings.extensionStatusRow),
-  };
-}
-
-export function cloneConfig(config: StatuslineConfig): StatuslineConfig {
-  return {
-    ...cloneSettings(config),
-    lines: config.lines.map((line) =>
-      line.map((widget) => ({ ...widget, options: { ...widget.options } })),
-    ),
-  };
-}
-
-export async function loadConfig(path = getConfigPath()): Promise<StatuslineConfig> {
-  try {
-    const raw = await readFile(path, "utf8");
-    return normalizeConfig(JSON.parse(raw));
-  } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT") {
-      return cloneConfig(DEFAULT_CONFIG);
-    }
-    throw error;
-  }
-}
-
-export async function saveConfig(config: StatuslineConfig, path = getConfigPath()): Promise<void> {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(normalizeConfig(config), null, 2)}\n`, "utf8");
-}
-
-function normalizeLines(linesValue: unknown, preset: Preset): WidgetEntry[][] {
-  if (!Array.isArray(linesValue)) return linesForPreset(preset);
-  return linesValue.map((line) => normalizeWidgets(line));
-}
-
-function normalizeWidgets(value: unknown): WidgetEntry[] {
-  if (!Array.isArray(value)) return [];
-
-  const widgets: WidgetEntry[] = [];
-  for (const item of value) {
-    if (!isRecord(item) || typeof item.type !== "string") continue;
-    const spec = registry.maybeSpec(item.type);
-    if (!spec) continue;
-    widgets.push({
-      id:
-        typeof item.id === "string" && item.id.length > 0
-          ? item.id
-          : registry.createEntry(spec.type as WidgetType).id,
-      type: spec.type as WidgetType,
-      enabled: typeof item.enabled === "boolean" ? item.enabled : true,
-      options: registry.normalizeOptions(
-        spec.type as WidgetType,
-        isRecord(item.options) ? item.options : {},
-      ),
-    });
-  }
-
-  return widgets;
-}
-
-function normalizeTerminalOptions(
-  value: unknown,
-  defaults: Partial<TerminalOptions> = {},
-): TerminalOptions {
-  const base = { ...DEFAULT_TERMINAL_OPTIONS, ...defaults };
-  if (!isRecord(value)) return base;
-  return {
-    widthMode:
-      typeof value.widthMode === "string" &&
-      TERMINAL_WIDTH_MODE_VALUES.includes(value.widthMode as TerminalWidthMode)
-        ? (value.widthMode as TerminalWidthMode)
-        : base.widthMode,
-    colorLevel:
-      typeof value.colorLevel === "string" &&
-      COLOR_LEVEL_VALUES.includes(value.colorLevel as ColorLevel)
-        ? (value.colorLevel as ColorLevel)
-        : base.colorLevel,
-  };
-}
-
-export function isPreset(value: unknown): value is Preset {
-  return typeof value === "string" && Object.hasOwn(PRESET_DEFINITIONS, value);
-}
-
-function isSeparatorStyle(value: unknown): value is SeparatorStyle {
-  return typeof value === "string" && SEPARATORS.has(value as SeparatorStyle);
-}
-
-function isIconMode(value: unknown): value is IconMode {
-  return typeof value === "string" && ICON_MODE_VALUES.includes(value as IconMode);
-}
-
-function isNodeError(error: unknown): error is NodeJS.ErrnoException {
-  return error instanceof Error && "code" in error;
-}

package/node_modules/pi-footer/src/event-widgets.ts

@@ -1,41 +0,0 @@
-import { isRecord } from "./types.js";
-
-export const UPDATE_EVENT_WIDGET_EVENT = "pi-footer:update-widget";
-
-interface UpdateEventWidgetPayload {
-  widgetId: string;
-  value: string | null;
-}
-
-const EVENT_WIDGET_ID_PREFIX = "event_";
-
-export function createEventWidgetId(): string {
-  return `${EVENT_WIDGET_ID_PREFIX}${Math.random().toString(36).slice(2, 10)}`;
-}
-
-export class EventWidgetValues {
-  private readonly valuesById = new Map<string, string>();
-
-  get values(): ReadonlyMap<string, string> {
-    return this.valuesById;
-  }
-
-  update(payload: unknown): boolean {
-    if (!isUpdatePayload(payload)) return false;
-    if (payload.value === null) {
-      return this.valuesById.delete(payload.widgetId);
-    }
-    const previous = this.valuesById.get(payload.widgetId);
-    this.valuesById.set(payload.widgetId, payload.value);
-    return previous !== payload.value;
-  }
-}
-
-function isUpdatePayload(value: unknown): value is UpdateEventWidgetPayload {
-  if (!isRecord(value)) return false;
-  return (
-    typeof value.widgetId === "string" &&
-    value.widgetId.length > 0 &&
-    (typeof value.value === "string" || value.value === null)
-  );
-}

package/node_modules/pi-footer/src/extension-statuses.ts

@@ -1,102 +0,0 @@
-import { isRecord } from "./types.js";
-
-export const EMPTY_STATUS_LABEL = "[Empty status]";
-
-export interface ExtensionStatusRowConfig {
-  hiddenKeys: string[];
-  knownKeys: string[];
-}
-
-interface ExtensionStatusEntry {
-  key: string;
-  value: string;
-  published: boolean;
-}
-
-export type GetExtensionStatuses = () => ReadonlyMap<string, string>;
-
-export const DEFAULT_EXTENSION_STATUS_ROW: ExtensionStatusRowConfig = {
-  hiddenKeys: [],
-  knownKeys: [],
-};
-
-export const EMPTY_EXTENSION_STATUSES: ReadonlyMap<string, string> = new Map<string, string>();
-
-export function extensionStatusEntries(
-  statuses: ReadonlyMap<string, string>,
-  ownStatusKey: string,
-): ExtensionStatusEntry[] {
-  return [...statuses.entries()]
-    .filter(([key, value]) => key !== ownStatusKey && value.length > 0)
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([key, value]) => ({ key, value, published: true }));
-}
-
-export function allExtensionStatusEntries(
-  statuses: ReadonlyMap<string, string>,
-  rowConfig: ExtensionStatusRowConfig,
-  ownStatusKey: string,
-): ExtensionStatusEntry[] {
-  const keys = new Set([...statuses.keys(), ...rowConfig.hiddenKeys, ...rowConfig.knownKeys]);
-  return [...keys]
-    .filter((key) => key.length > 0 && key !== ownStatusKey)
-    .sort((left, right) => left.localeCompare(right))
-    .map((key) => {
-      const value = statuses.get(key) ?? "";
-      return {
-        key,
-        value: value.length > 0 ? value : EMPTY_STATUS_LABEL,
-        published: value.length > 0,
-      };
-    });
-}
-
-export function visibleExtensionStatusRowEntries(
-  statuses: ReadonlyMap<string, string>,
-  hiddenKeys: readonly string[],
-  ownStatusKey: string,
-): ExtensionStatusEntry[] {
-  const hidden = new Set(hiddenKeys);
-  return extensionStatusEntries(statuses, ownStatusKey).filter((entry) => !hidden.has(entry.key));
-}
-
-export function toggleExtensionStatusRowKey(
-  rowConfig: ExtensionStatusRowConfig,
-  key: string,
-): ExtensionStatusRowConfig {
-  const hidden = new Set(rowConfig.hiddenKeys);
-  const known = new Set(rowConfig.knownKeys);
-  known.add(key);
-  if (hidden.has(key)) hidden.delete(key);
-  else hidden.add(key);
-  return {
-    hiddenKeys: sortedKeys(hidden),
-    knownKeys: sortedKeys(known),
-  };
-}
-
-export function normalizeExtensionStatusRow(value: unknown): ExtensionStatusRowConfig {
-  if (!isRecord(value)) return cloneExtensionStatusRow(DEFAULT_EXTENSION_STATUS_ROW);
-  return {
-    hiddenKeys: normalizeKeyList(value.hiddenKeys),
-    knownKeys: normalizeKeyList(value.knownKeys),
-  };
-}
-
-export function cloneExtensionStatusRow(value: ExtensionStatusRowConfig): ExtensionStatusRowConfig {
-  return {
-    hiddenKeys: [...value.hiddenKeys],
-    knownKeys: [...value.knownKeys],
-  };
-}
-
-function normalizeKeyList(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  return sortedKeys(
-    new Set(value.filter((key): key is string => typeof key === "string" && key.length > 0)),
-  );
-}
-
-function sortedKeys(keys: Iterable<string>): string[] {
-  return [...keys].sort((left, right) => left.localeCompare(right));
-}