@agi-fans/dsh-tui 0.20.0 → 0.22.0

package/lib/chrome/status-config.d.ts

@@ -1,83 +1,193 @@
 /**
  * Status-line customization shared by settings, persistence, and rendering.
+ *
+ * The footer is two rows of fixed copy. This module owns *which* parts of those
+ * rows appear and how much of each telemetry group is shown — nothing more.
+ *
+ * There used to be a layout engine here: twelve independently placed items, each
+ * with its own colour, its own column, and two levels of ordering, plus a legacy
+ * `metrics` colour slot for groups that had no colour of their own. That is a
+ * page of settings for a two-line footer, and it asked the reader to decide
+ * things the footer could decide better. The reader now picks a density, and can
+ * turn individual telemetry groups off when a terminal is narrow or a metric is
+ * not interesting to them.
+ *
  * @module @agi-fans/dsh-tui/status-config
  */
 import type { VolatileSnapshot } from '@deepseek-ai/cordis';
-/** Stable telemetry groups users can show, hide, and reorder. */
+/**
+ * Telemetry groups on the second line, in the order they are shown.
+ *
+ * The order is fixed and follows the priority stated in `AGENTS.md`: cache,
+ * tokens, and latency first because they say how the turn is going; durations
+ * second; turn and step counts last, because they are the least actionable.
+ */
 export declare const STATUS_GROUP_IDS: readonly ["context", "cache", "tokens", "speed", "durations", "counts"];
 export type StatusGroupId = (typeof STATUS_GROUP_IDS)[number];
 /** First-line pieces: model, reasoning effort, workspace path, Git branch, and session title. */
 export declare const STATUS_META_IDS: readonly ["model", "effort", "path", "git", "session"];
 export type StatusMetaId = (typeof STATUS_META_IDS)[number];
-/** Every independently placed footer item. */
+/** Every part of the footer a reader can show or hide. */
 export declare const STATUS_ITEM_IDS: readonly ["model", "effort", "path", "git", "session", "context", "cache", "tokens", "speed", "durations", "counts"];
 export type StatusItemId = (typeof STATUS_ITEM_IDS)[number];
 export declare const STATUS_LABEL_STYLES: readonly ["compact", "full"];
 export type StatusLabelStyle = (typeof STATUS_LABEL_STYLES)[number];
+/** How context occupancy is written, which is a rendering choice, not a layout one. */
 export declare const STATUS_CONTEXT_STYLES: readonly ["percent", "bar", "tokens", "detailed"];
 export type StatusContextStyle = (typeof STATUS_CONTEXT_STYLES)[number];
 /**
- * Color slots: one per preview item, plus legacy `metrics` as a fallback for
- * telemetry groups that do not have their own color yet.
+ * How much the footer says.
+ *
+ * A density is the whole vocabulary now: three whole-footer shapes a reader can
+ * recognize, instead of twelve items they have to assemble. Individual groups
+ * can still be hidden on top of one, which is the one per-item decision that
+ * survives — "I do not care about this number" is real, "put this number on the
+ * left in accent green" is chrome nobody asked for.
+ */
+export declare const STATUS_DENSITIES: readonly ["minimal", "standard", "verbose"];
+export type StatusDensity = (typeof STATUS_DENSITIES)[number];
+/**
+ * Which telemetry row each group is drawn on.
+ *
+ * Two rows exist so the widest density can state everything without dropping
+ * anything: the first row is the window and the turn in flight, the second is
+ * what the session has accumulated. `minimal` and `standard` only fill the first
+ * row, so their footer stays two lines; the row is a property of the group, not
+ * of the density, so nothing moves between rows when the density changes.
+ */
+export declare const STATUS_ROWS: readonly (readonly StatusGroupId[])[];
+/**
+ * Groups drawn against the left edge of their row.
+ *
+ * A row answers two questions from opposite edges, and each side keeps its
+ * meaning down the footer: occupancy and the time already spent read on the
+ * left, throughput and the count of work done on the right.
+ */
+export declare const STATUS_LEFT_GROUPS: readonly StatusGroupId[];
+/** Which telemetry row a group is drawn on; 0 is the row under the composer. */
+export declare function statusGroupRow(id: StatusGroupId): number;
+/** Which side of its row a group is drawn on. */
+export declare function statusGroupSide(id: StatusGroupId): 'left' | 'right';
+/** Which groups each density shows, in footer order. */
+export declare const DENSITY_GROUPS: Readonly<Record<StatusDensity, readonly StatusGroupId[]>>;
+/** Which first-line pieces each density shows. */
+export declare const DENSITY_META: Readonly<Record<StatusDensity, readonly StatusMetaId[]>>;
+/** The label style each density defaults to. */
+export declare const DENSITY_LABELS: Readonly<Record<StatusDensity, StatusLabelStyle>>;
+/** The context representation each density defaults to. */
+export declare const DENSITY_CONTEXT: Readonly<Record<StatusDensity, StatusContextStyle>>;
+export declare const DEFAULT_STATUS_DENSITY: StatusDensity;
+/**
+ * Stored status-line input.
+ *
+ * `density` is the whole user-facing decision. `meta` and `groups` are narrowings
+ * on top of it: a reader who turned a number off keeps it off across densities,
+ * because hiding something is a statement about the number, not about the layout.
  */
-export declare const STATUS_COLOR_SLOTS: readonly ["model", "effort", "path", "git", "session", "context", "cache", "tokens", "speed", "durations", "counts", "metrics"];
-export type StatusColorSlot = (typeof STATUS_COLOR_SLOTS)[number];
-/** Theme tokens offered for a status item. `default` keeps the built-in hierarchy. */
-export declare const STATUS_COLOR_TOKENS: readonly ["default", "text", "muted", "accent", "success", "warning", "border", "label"];
-export type StatusColorToken = (typeof STATUS_COLOR_TOKENS)[number];
-/** Footer column an item can occupy. */
-export declare const STATUS_SIDES: readonly ["left", "right"];
-export type StatusSide = (typeof STATUS_SIDES)[number];
-export declare const DEFAULT_STATUS_SIDES: Record<StatusItemId, StatusSide>;
-/** Per-item color choices. Omitted items keep their built-in tone. */
-export type StatusBarColors = Partial<Record<StatusColorSlot, StatusColorToken>>;
-/** User-owned status-line layout. Missing `groups`/`meta` are hidden; `order` retains their slots. */
 export interface StatusBarConfig {
+    density: StatusDensity;
+    /**
+     * Whether the second line is drawn at all.
+     *
+     * Kept as its own field rather than expressed as "every group hidden": hiding
+     * all of them and calling that off would forget what to bring back when the
+     * reader turns telemetry on again.
+     */
+    enabled?: boolean;
+    /** Pieces the reader hid, on top of what the density shows. */
+    hidden: StatusItemId[];
+    /**
+     * Pieces the reader added beyond what the density shows.
+     *
+     * Without this, a part the density omits could not be turned on at all: `Space`
+     * on it was a no-op, while the row still said `hidden` — a control that looked
+     * broken. Positive and negative narrowing are both deltas from the density, so
+     * changing the density still changes everything the reader has not overruled.
+     */
+    shown: StatusItemId[];
+}
+/** A status-line document, including every field earlier releases wrote. */
+export type StatusBarInput = Partial<VolatileSnapshot<StatusBarConfig>> & {
+    /** Earlier releases spelled the whole layout out; read only while migrating. */
+    enabled?: boolean;
+    labels?: StatusLabelStyle;
+    contextStyle?: StatusContextStyle;
+    groups?: readonly StatusGroupId[];
+    order?: readonly StatusGroupId[];
+    meta?: readonly StatusMetaId[];
+    metaOrder?: readonly StatusMetaId[];
+    colors?: Readonly<Record<string, string>>;
+    sides?: Readonly<Record<string, string>>;
+};
+/** What the renderer consumes: the density expanded, with narrowings applied. */
+export interface ResolvedStatusBarConfig {
+    density: StatusDensity;
+    /** False when the reader hid the whole second line. */
     enabled: boolean;
     labels: StatusLabelStyle;
-    /** Context occupancy representation; omitted preferences default to percent. */
-    contextStyle?: StatusContextStyle;
-    groups: StatusGroupId[];
-    /** Complete visual order, including hidden groups. Absent in legacy settings. */
-    order?: StatusGroupId[];
-    /** Visible first-line items. Absent means every meta item is shown. */
-    meta?: StatusMetaId[];
-    /** Complete first-line order, including hidden meta items. */
-    metaOrder?: StatusMetaId[];
-    /** Optional per-item colors for the two-line footer. */
-    colors?: StatusBarColors;
-    /** Optional left/right column for each item. */
-    sides?: Partial<Record<StatusItemId, StatusSide>>;
-}
-/** Stored status-line input: a settings document value or a frozen config snapshot. */
-export type StatusBarInput = Partial<VolatileSnapshot<StatusBarConfig>>;
-/** Normalized layout always carries complete orders, colors, and columns. */
-export interface ResolvedStatusBarConfig extends StatusBarConfig {
     contextStyle: StatusContextStyle;
-    order: StatusGroupId[];
+    /** Visible telemetry groups, in fixed footer order. */
+    groups: StatusGroupId[];
+    /** Visible first-line pieces, in fixed footer order. */
     meta: StatusMetaId[];
-    metaOrder: StatusMetaId[];
-    colors: Required<StatusBarColors>;
-    sides: Record<StatusItemId, StatusSide>;
 }
-/** Legacy value accepted while existing settings documents migrate. */
+/** Earlier releases stored a three-value `statusPreset` beside the layout. */
 export declare const STATUS_PRESETS: readonly ["minimal", "compact", "full"];
 export type StatusPreset = (typeof STATUS_PRESETS)[number];
+/** Everything shown at the shipped density. */
 export declare const DEFAULT_STATUS_GROUPS: readonly StatusGroupId[];
-/**
- * Session title is offered but off by default: adding it to the first line
- * would push narrow terminals into degradation sooner. The terminal window
- * title carries it unconditionally.
- */
 export declare const DEFAULT_STATUS_META: readonly StatusMetaId[];
-export declare const DEFAULT_STATUS_COLORS: Required<StatusBarColors>;
-/** Return a fresh default so callers can safely replace its group list. */
-export declare function defaultStatusBarConfig(): ResolvedStatusBarConfig;
-export declare function isStatusMetaId(value: unknown): value is StatusMetaId;
 export declare function isStatusItemId(value: unknown): value is StatusItemId;
-export declare function itemSide(config: StatusBarConfig, id: StatusItemId): StatusSide;
+export declare function isStatusMetaId(value: unknown): value is StatusMetaId;
+export declare function isStatusGroupId(value: unknown): value is StatusGroupId;
 /**
- * Normalize persisted input at the single configuration seam. Invalid and
- * duplicate groups disappear; legacy presets retain their previous meaning.
+ * Normalize persisted input at the single configuration seam.
+ *
+ * A document written by an earlier release described its layout item by item.
+ * Rather than fail it or resurrect the engine, the shape it asked for is reduced
+ * to the nearest density: what was visible decides the narrowing, and the retired
+ * per-item colour and column choices are dropped, because both shipped palettes
+ * already paint them the right way.
  */
 export declare function resolveStatusBarConfig(config?: StatusBarInput, legacyPreset?: StatusPreset): ResolvedStatusBarConfig;
+/**
+ * What a stored document asks to hide, relative to its density.
+ *
+ * Exported because writing the document back needs the same reading: a caller
+ * that reconstructed the narrowing from the *rendered* footer instead would turn
+ * every part its density happens to omit into a permanent hiding, and changing
+ * the density afterwards would no longer restore them.
+ */
+export declare function statusNarrowing(config: StatusBarInput | undefined, density: StatusDensity): StatusItemId[];
+/** What a stored document adds beyond its density. */
+export declare function statusAdditions(config: StatusBarInput | undefined): StatusItemId[];
+/**
+ * True when a document has already been expanded.
+ *
+ * `resolveStatusBarConfig` is idempotent only if it can tell the two shapes
+ * apart: an expanded config carries `groups`/`meta`, which a stored document
+ * never does. Without this the renderer re-resolved its own input and silently
+ * dropped every narrowing, so a hidden group came back.
+ */
+export declare function isResolvedStatusBarConfig(config: ResolvedStatusBarConfig | StatusBarInput): config is ResolvedStatusBarConfig;
+/**
+ * The document a resolved config came from.
+ *
+ * Visibility cannot say which of two reasons a part is missing: the reader hid
+ * it, or the density never included it. Rebuilding the document from what the
+ * footer shows therefore has to keep them apart — a part the density omits must
+ * stay out of `hidden`, or raising the density would silently do nothing — and it
+ * is the only way a caller that holds the resolved form (the provider holds the
+ * footer it is drawing) can hand the document back without losing a choice.
+ */
+export declare function statusBarDocument(config: ResolvedStatusBarConfig): StatusBarConfig;
+/** True when the footer shows this part at the current narrowing. */
+export declare function statusItemVisible(config: ResolvedStatusBarConfig, id: StatusItemId): boolean;
+/**
+ * The same document with one part turned on or off.
+ *
+ * Both directions are deltas from the density, so a part the density omits can
+ * be added and a part it includes can be removed, without either one rewriting
+ * the other's state.
+ */
+export declare function toggleStatusItem(config: StatusBarConfig, id: StatusItemId): StatusBarConfig;

package/lib/chrome/status-config.js

@@ -1,159 +1,270 @@
 /**
  * Status-line customization shared by settings, persistence, and rendering.
+ *
+ * The footer is two rows of fixed copy. This module owns *which* parts of those
+ * rows appear and how much of each telemetry group is shown — nothing more.
+ *
+ * There used to be a layout engine here: twelve independently placed items, each
+ * with its own colour, its own column, and two levels of ordering, plus a legacy
+ * `metrics` colour slot for groups that had no colour of their own. That is a
+ * page of settings for a two-line footer, and it asked the reader to decide
+ * things the footer could decide better. The reader now picks a density, and can
+ * turn individual telemetry groups off when a terminal is narrow or a metric is
+ * not interesting to them.
+ *
  * @module @agi-fans/dsh-tui/status-config
  */
-/** Stable telemetry groups users can show, hide, and reorder. */
+/**
+ * Telemetry groups on the second line, in the order they are shown.
+ *
+ * The order is fixed and follows the priority stated in `AGENTS.md`: cache,
+ * tokens, and latency first because they say how the turn is going; durations
+ * second; turn and step counts last, because they are the least actionable.
+ */
 export const STATUS_GROUP_IDS = ['context', 'cache', 'tokens', 'speed', 'durations', 'counts'];
 /** First-line pieces: model, reasoning effort, workspace path, Git branch, and session title. */
 export const STATUS_META_IDS = ['model', 'effort', 'path', 'git', 'session'];
-/** Every independently placed footer item. */
+/** Every part of the footer a reader can show or hide. */
 export const STATUS_ITEM_IDS = [...STATUS_META_IDS, ...STATUS_GROUP_IDS];
 export const STATUS_LABEL_STYLES = ['compact', 'full'];
+/** How context occupancy is written, which is a rendering choice, not a layout one. */
 export const STATUS_CONTEXT_STYLES = ['percent', 'bar', 'tokens', 'detailed'];
 /**
- * Color slots: one per preview item, plus legacy `metrics` as a fallback for
- * telemetry groups that do not have their own color yet.
+ * How much the footer says.
+ *
+ * A density is the whole vocabulary now: three whole-footer shapes a reader can
+ * recognize, instead of twelve items they have to assemble. Individual groups
+ * can still be hidden on top of one, which is the one per-item decision that
+ * survives — "I do not care about this number" is real, "put this number on the
+ * left in accent green" is chrome nobody asked for.
  */
-export const STATUS_COLOR_SLOTS = [...STATUS_ITEM_IDS, 'metrics'];
-/** Theme tokens offered for a status item. `default` keeps the built-in hierarchy. */
-export const STATUS_COLOR_TOKENS = ['default', 'text', 'muted', 'accent', 'success', 'warning', 'border', 'label'];
-/** Footer column an item can occupy. */
-export const STATUS_SIDES = ['left', 'right'];
-export const DEFAULT_STATUS_SIDES = {
-    model: 'left',
-    effort: 'left',
-    path: 'right',
-    git: 'right',
-    session: 'left',
-    context: 'left',
-    cache: 'left',
-    tokens: 'left',
-    speed: 'left',
-    durations: 'right',
-    counts: 'right',
-};
-/** Legacy value accepted while existing settings documents migrate. */
-export const STATUS_PRESETS = ['minimal', 'compact', 'full'];
-export const DEFAULT_STATUS_GROUPS = STATUS_GROUP_IDS;
+export const STATUS_DENSITIES = ['minimal', 'standard', 'verbose'];
+/**
+ * Which telemetry row each group is drawn on.
+ *
+ * Two rows exist so the widest density can state everything without dropping
+ * anything: the first row is the window and the turn in flight, the second is
+ * what the session has accumulated. `minimal` and `standard` only fill the first
+ * row, so their footer stays two lines; the row is a property of the group, not
+ * of the density, so nothing moves between rows when the density changes.
+ */
+export const STATUS_ROWS = [
+    ['context', 'cache', 'tokens', 'speed'],
+    ['durations', 'counts'],
+];
 /**
- * Session title is offered but off by default: adding it to the first line
- * would push narrow terminals into degradation sooner. The terminal window
- * title carries it unconditionally.
+ * Groups drawn against the left edge of their row.
+ *
+ * A row answers two questions from opposite edges, and each side keeps its
+ * meaning down the footer: occupancy and the time already spent read on the
+ * left, throughput and the count of work done on the right.
  */
-export const DEFAULT_STATUS_META = ['model', 'effort', 'path', 'git'];
-export const DEFAULT_STATUS_COLORS = {
-    model: 'default',
-    effort: 'default',
-    path: 'default',
-    git: 'default',
-    session: 'default',
-    metrics: 'default',
-    context: 'default',
-    cache: 'default',
-    tokens: 'default',
-    speed: 'default',
-    durations: 'default',
-    counts: 'default',
+export const STATUS_LEFT_GROUPS = ['context', 'cache', 'durations'];
+/** Which telemetry row a group is drawn on; 0 is the row under the composer. */
+export function statusGroupRow(id) {
+    const row = STATUS_ROWS.findIndex(groups => groups.includes(id));
+    return row < 0 ? 0 : row;
+}
+/** Which side of its row a group is drawn on. */
+export function statusGroupSide(id) {
+    return STATUS_LEFT_GROUPS.includes(id) ? 'left' : 'right';
+}
+/** Which groups each density shows, in footer order. */
+export const DENSITY_GROUPS = {
+    /** Occupancy only: how full the window is and how much of it came from cache. */
+    minimal: ['context', 'cache'],
+    /** Adds latency — the first number that says a turn feels slow rather than long. */
+    standard: ['context', 'cache', 'speed'],
+    /** Every group, with full labels and the detailed context form. */
+    verbose: [...STATUS_GROUP_IDS],
 };
-/** Return a fresh default so callers can safely replace its group list. */
-export function defaultStatusBarConfig() {
-    return {
-        enabled: true,
-        labels: 'compact',
-        contextStyle: 'percent',
-        groups: [...DEFAULT_STATUS_GROUPS],
-        order: [...DEFAULT_STATUS_GROUPS],
-        meta: [...DEFAULT_STATUS_META],
-        // Every meta id keeps its slot so the settings list stays stable when an
-        // item is toggled; only `meta` decides what is actually painted.
-        metaOrder: [...STATUS_META_IDS],
-        colors: { ...DEFAULT_STATUS_COLORS },
-        sides: { ...DEFAULT_STATUS_SIDES },
-    };
+/** Which first-line pieces each density shows. */
+export const DENSITY_META = {
+    /** Where the model is and where the work is; the footer's original two facts. */
+    minimal: ['model', 'path'],
+    standard: ['model', 'effort', 'path', 'git'],
+    /** `session` joins at the widest setting; the terminal title shows it anyway. */
+    verbose: ['model', 'effort', 'path', 'git', 'session'],
+};
+/** The label style each density defaults to. */
+export const DENSITY_LABELS = {
+    minimal: 'compact',
+    standard: 'compact',
+    verbose: 'full',
+};
+/** The context representation each density defaults to. */
+export const DENSITY_CONTEXT = {
+    minimal: 'percent',
+    standard: 'percent',
+    verbose: 'detailed',
+};
+export const DEFAULT_STATUS_DENSITY = 'standard';
+/** Earlier releases stored a three-value `statusPreset` beside the layout. */
+export const STATUS_PRESETS = ['minimal', 'compact', 'full'];
+/** Everything shown at the shipped density. */
+export const DEFAULT_STATUS_GROUPS = DENSITY_GROUPS[DEFAULT_STATUS_DENSITY];
+export const DEFAULT_STATUS_META = DENSITY_META[DEFAULT_STATUS_DENSITY];
+function isStatusDensity(value) {
+    return typeof value === 'string' && STATUS_DENSITIES.includes(value);
 }
-function isStatusGroupId(value) {
-    return typeof value === 'string' && STATUS_GROUP_IDS.includes(value);
+export function isStatusItemId(value) {
+    return typeof value === 'string' && STATUS_ITEM_IDS.includes(value);
 }
 export function isStatusMetaId(value) {
     return typeof value === 'string' && STATUS_META_IDS.includes(value);
 }
-export function isStatusItemId(value) {
-    return typeof value === 'string' && STATUS_ITEM_IDS.includes(value);
+export function isStatusGroupId(value) {
+    return typeof value === 'string' && STATUS_GROUP_IDS.includes(value);
 }
-function isStatusLabelStyle(value) {
-    return typeof value === 'string' && STATUS_LABEL_STYLES.includes(value);
+/**
+ * Map a retired `statusPreset` onto a density.
+ *
+ * `minimal` meant "no second line"; that is now `minimal` density with telemetry
+ * hidden, which is the same footer the reader had. `full` meant long labels,
+ * which is what `verbose` says.
+ */
+function densityFromPreset(preset) {
+    if (preset === 'minimal')
+        return { density: 'minimal', enabled: false };
+    if (preset === 'full')
+        return { density: 'verbose', enabled: true };
+    return { density: DEFAULT_STATUS_DENSITY, enabled: true };
 }
-function isStatusColorToken(value) {
-    return typeof value === 'string' && STATUS_COLOR_TOKENS.includes(value);
+/**
+ * Normalize persisted input at the single configuration seam.
+ *
+ * A document written by an earlier release described its layout item by item.
+ * Rather than fail it or resurrect the engine, the shape it asked for is reduced
+ * to the nearest density: what was visible decides the narrowing, and the retired
+ * per-item colour and column choices are dropped, because both shipped palettes
+ * already paint them the right way.
+ */
+export function resolveStatusBarConfig(config, legacyPreset) {
+    const fallback = densityFromPreset(legacyPreset);
+    if (config === undefined)
+        return expand(fallback.density, { enabled: fallback.enabled, hidden: [] });
+    const density = isStatusDensity(config.density) ? config.density : fallback.density;
+    /**
+     * A legacy document listed what it wanted shown; a current one lists what it
+     * wants hidden. Both cannot be read from `density`: the schema defaults that
+     * field, so an old document arrives here already looking current, while the
+     * layout arrays only exist on an old one.
+     */
+    const enabled = typeof config.enabled === 'boolean' ? config.enabled : fallback.enabled;
+    return expand(density, { enabled, hidden: statusNarrowing(config, density), shown: statusAdditions(config) });
+}
+/**
+ * What a stored document asks to hide, relative to its density.
+ *
+ * Exported because writing the document back needs the same reading: a caller
+ * that reconstructed the narrowing from the *rendered* footer instead would turn
+ * every part its density happens to omit into a permanent hiding, and changing
+ * the density afterwards would no longer restore them.
+ */
+export function statusNarrowing(config, density) {
+    if (config === undefined)
+        return [];
+    const legacyLayout = config.groups !== undefined || config.meta !== undefined
+        || config.order !== undefined || config.metaOrder !== undefined;
+    return legacyLayout
+        ? legacyHidden(config, density)
+        : [...new Set((config.hidden ?? []).filter(isStatusItemId))];
 }
-function isStatusSide(value) {
-    return value === 'left' || value === 'right';
+/** What a stored document adds beyond its density. */
+export function statusAdditions(config) {
+    return [...new Set((config?.shown ?? []).filter(isStatusItemId))];
 }
-export function itemSide(config, id) {
-    return config.sides?.[id] ?? DEFAULT_STATUS_SIDES[id];
+/** What an earlier release's explicit lists hid, expressed as a narrowing. */
+function legacyHidden(config, density) {
+    const shownGroups = config.groups === undefined ? DENSITY_GROUPS[density] : config.groups;
+    const shownMeta = config.meta === undefined ? DENSITY_META[density] : config.meta;
+    const hidden = [];
+    for (const id of STATUS_GROUP_IDS)
+        if (!shownGroups.includes(id))
+            hidden.push(id);
+    for (const id of STATUS_META_IDS)
+        if (!shownMeta.includes(id))
+            hidden.push(id);
+    return hidden;
 }
-function resolveStatusSides(sides) {
-    const resolved = { ...DEFAULT_STATUS_SIDES };
-    if (sides === undefined)
-        return resolved;
+/**
+ * True when a document has already been expanded.
+ *
+ * `resolveStatusBarConfig` is idempotent only if it can tell the two shapes
+ * apart: an expanded config carries `groups`/`meta`, which a stored document
+ * never does. Without this the renderer re-resolved its own input and silently
+ * dropped every narrowing, so a hidden group came back.
+ */
+export function isResolvedStatusBarConfig(config) {
+    return Array.isArray(config.groups)
+        && Array.isArray(config.meta)
+        && typeof config.enabled === 'boolean';
+}
+/** Expand one density plus its deltas into the renderer's view. */
+function expand(density, options) {
+    const hidden = new Set(options.hidden);
+    const shown = new Set(options.shown ?? []);
+    // Catalog order, so a part the reader added sits where its family sits rather
+    // than at the end of the row where it would move every time it is toggled.
+    const visible = (catalog, base) => catalog.filter(id => (base.includes(id) || shown.has(id)) && !hidden.has(id));
+    return {
+        density,
+        enabled: options.enabled,
+        labels: DENSITY_LABELS[density],
+        contextStyle: DENSITY_CONTEXT[density],
+        groups: visible(STATUS_GROUP_IDS, DENSITY_GROUPS[density]),
+        meta: visible(STATUS_META_IDS, DENSITY_META[density]),
+    };
+}
+/**
+ * The document a resolved config came from.
+ *
+ * Visibility cannot say which of two reasons a part is missing: the reader hid
+ * it, or the density never included it. Rebuilding the document from what the
+ * footer shows therefore has to keep them apart — a part the density omits must
+ * stay out of `hidden`, or raising the density would silently do nothing — and it
+ * is the only way a caller that holds the resolved form (the provider holds the
+ * footer it is drawing) can hand the document back without losing a choice.
+ */
+export function statusBarDocument(config) {
+    const densityHas = (id) => isStatusMetaId(id) ? DENSITY_META[config.density].includes(id) : DENSITY_GROUPS[config.density].includes(id);
+    const hidden = [];
+    const shown = [];
     for (const id of STATUS_ITEM_IDS) {
-        const side = sides[id];
-        if (isStatusSide(side))
-            resolved[id] = side;
-    }
-    return resolved;
-}
-function completeOrder(ids, preferred) {
-    const ordered = [...new Set(preferred.filter((id) => ids.includes(id)))];
-    return [...ordered, ...ids.filter(id => !ordered.includes(id))];
-}
-function resolveStatusColors(colors) {
-    const resolved = { ...DEFAULT_STATUS_COLORS };
-    if (colors === undefined)
-        return resolved;
-    for (const slot of STATUS_COLOR_SLOTS) {
-        const token = colors[slot];
-        if (isStatusColorToken(token))
-            resolved[slot] = token;
-    }
-    const legacyMetrics = resolved.metrics;
-    if (legacyMetrics !== 'default') {
-        for (const group of STATUS_GROUP_IDS) {
-            if (colors[group] === undefined)
-                resolved[group] = legacyMetrics;
-        }
+        const visible = statusItemVisible(config, id);
+        if (visible === densityHas(id))
+            continue;
+        if (visible)
+            shown.push(id);
+        else
+            hidden.push(id);
     }
-    return resolved;
+    return { density: config.density, hidden, shown, enabled: config.enabled };
+}
+/** True when the footer shows this part at the current narrowing. */
+export function statusItemVisible(config, id) {
+    return isStatusMetaId(id) ? config.meta.includes(id) : config.groups.includes(id);
 }
 /**
- * Normalize persisted input at the single configuration seam. Invalid and
- * duplicate groups disappear; legacy presets retain their previous meaning.
+ * The same document with one part turned on or off.
+ *
+ * Both directions are deltas from the density, so a part the density omits can
+ * be added and a part it includes can be removed, without either one rewriting
+ * the other's state.
  */
-export function resolveStatusBarConfig(config, legacyPreset) {
-    if (config === undefined) {
-        const fallback = defaultStatusBarConfig();
-        if (legacyPreset === 'minimal')
-            fallback.enabled = false;
-        if (legacyPreset === 'full')
-            fallback.labels = 'full';
-        return fallback;
+export function toggleStatusItem(config, id) {
+    const density = isStatusDensity(config.density) ? config.density : DEFAULT_STATUS_DENSITY;
+    const hidden = new Set((config.hidden ?? []).filter(isStatusItemId));
+    const shown = new Set((config.shown ?? []).filter(isStatusItemId));
+    const visible = statusItemVisible(expand(density, { enabled: true, hidden: [...hidden], shown: [...shown] }), id);
+    if (visible) {
+        hidden.add(id);
+        shown.delete(id);
     }
-    const groups = config.groups === undefined
-        ? [...DEFAULT_STATUS_GROUPS]
-        : [...new Set(config.groups.filter(isStatusGroupId))];
-    const meta = config.meta === undefined
-        ? [...DEFAULT_STATUS_META]
-        : [...new Set(config.meta.filter(isStatusMetaId))];
-    return {
-        enabled: config.enabled ?? true,
-        labels: isStatusLabelStyle(config.labels) ? config.labels : 'compact',
-        contextStyle: STATUS_CONTEXT_STYLES.includes(config.contextStyle) ? config.contextStyle : 'percent',
-        groups,
-        order: completeOrder(STATUS_GROUP_IDS, config.order === undefined ? groups : config.order),
-        meta,
-        metaOrder: completeOrder(STATUS_META_IDS, config.metaOrder === undefined ? meta : config.metaOrder),
-        colors: resolveStatusColors(config.colors),
-        sides: resolveStatusSides(config.sides),
-    };
+    else {
+        shown.add(id);
+        hidden.delete(id);
+    }
+    return { ...config, hidden: [...hidden], shown: [...shown] };
 }
 //# sourceMappingURL=status-config.js.map