avtc-pi-settings-ui 1.0.0

package/src/type-definitions.ts

@@ -0,0 +1,301 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 avtc <tarasenkov@gmail.com>
+
+/**
+ * First-class setting types — the `TypeDefinition` registry.
+ *
+ * Each setting `type` is a registered `TypeDefinition` that owns its value↔string conversion
+ * and metadata. Seven built-ins ship; any extension can register more via
+ * `registerTypeDefinition` (same code path as the built-ins).
+ *
+ * Null/0/bounds/presets stay owned by `SettingSchema` + `presets` — a type only owns how a
+ * string becomes a value and back, plus a few metadata fields. The single normalization gate
+ * (of the design) consults `getTypeDefinition(type)` for parse/format/valueType/bounded.
+ */
+
+import { getCapturedCtx } from "./ctx-store.js";
+import { modelLabel, resolveModelPresets, splitModelId } from "./model-presets.js";
+import type { PresetPair, PresetsSource } from "./schema.js";
+import {
+  formatCompactThreshold,
+  formatHumanDuration,
+  isCompactThreshold,
+  parseCompactThreshold,
+  parseHumanDuration,
+} from "./validation.js";
+
+/** Per-call context handed to a `TypeDefinition`'s parse/format/prefill. */
+export interface TypeContext {
+  /** Effective presets for this setting, as `[label, value]` pairs. */
+  presets: readonly PresetPair[];
+  /** Inclusive numeric floor (from `SettingSchema.min`). */
+  min?: number;
+  /** Inclusive numeric ceiling (from `SettingSchema.max`). */
+  max?: number;
+}
+
+/** A first-class setting type. `T` is the parsed/kept JS value type (defaults to `unknown`). */
+export interface TypeDefinition<T = unknown> {
+  /** Type id ("number" | "duration" |... | <custom>); matches `SettingSchema.type`. */
+  id: string;
+  /** `typeof` of the parsed/kept value — drives the gate's step-5 type-match. */
+  valueType: "number" | "string" | "boolean";
+  /** string → value | invalid. Invalid MUST return `undefined`, never `null` (null is a preset value). */
+  parse(input: string, ctx: TypeContext): T | undefined;
+  /** value → display string. */
+  format(value: T, ctx: TypeContext): string;
+  /** Custom-input seed; defaults to `format` when absent. */
+  toInputPrefill?(value: T, ctx: TypeContext): string;
+  /** Can the user type free-form input for this type? */
+  supportsCustomValues: boolean;
+  /** Hint shown in the custom-value picker. */
+  errorMessage: string;
+  /** When true, the gate applies `min`/`max` bounds (number/duration). */
+  bounded?: boolean;
+  /**
+   * Optional DEFAULT presets for this type — overridden by `SettingSchema.presets` (replace, not
+   * merge) when the setting declares its own. Either level may be a static pair array (resolved
+   * at the gate) or a resolver function (resolved once at modal-open, e.g. a model list read
+   * from the registry). Absent means this type offers no default presets.
+   */
+  presets?: PresetsSource;
+}
+
+// ── Registry ────────────────────────────────────────────────────────────────
+
+const registry = new Map<string, TypeDefinition>();
+
+/**
+ * Register a setting type (built-ins are pre-registered at module load; extensions call this at
+ * startup for custom types). Stored as `TypeDefinition<unknown>` so heterogeneous definitions
+ * share one registry — the concrete `T` is an asserted shape, the same trust model as the gate.
+ */
+export function registerTypeDefinition<T>(def: TypeDefinition<T>): void {
+  registry.set(def.id, def as TypeDefinition<unknown>);
+}
+
+/** Look up a setting type by id — the single lookup replacing every type-keyed switch. */
+export function getTypeDefinition(typeId: string): TypeDefinition {
+  const def = registry.get(typeId);
+  if (!def) throw new Error(`Unknown setting type: ${typeId}`);
+  return def;
+}
+
+/**
+ * Coerce a serialized raw string to the type's JS value for `format`/`toInputPrefill`.
+ * Number-typed values are stored as numeric strings; this coerces them to a real number so
+ * `format(300000)` renders `"5m"` rather than failing. A non-numeric string (e.g. the null-label
+ * on a preset-less setting) falls back to the raw string. Used by schema-tabs (display) and
+ * value-picker (prefill) — the single coercion replacing their duplicated inline logic.
+ */
+export function coerceTypedValue(rawValue: string, typeDef: TypeDefinition): string | number {
+  if (typeDef.valueType === "number") {
+    const num = Number(rawValue);
+    return Number.isNaN(num) ? rawValue : num;
+  }
+  return rawValue;
+}
+
+/**
+ * Format a serialized raw value for display via the TypeDefinition. Coerces the raw string to
+ * the type's JS value, then formats it. A non-numeric result (e.g. the null-label "Infinite" on
+ * a preset-less setting) is returned verbatim rather than fed through `format` (which would
+ * render "NaNs" for durations). The single display-format site shared by schema-tabs (list
+ * display) and value-picker (prefill) — keeps the NaN guard from drifting between them.
+ */
+export function formatRawForDisplay(rawValue: string, typeDef: TypeDefinition, ctx: TypeContext): string {
+  // Run the type's format on the display path, else return the verbatim raw string.
+  // - number valueType: coerce to a number and format, but only when the raw is actually numeric —
+  //   a non-numeric raw (e.g. the null-label 'Infinite') is returned verbatim so format() never
+  //   receives a value it can't render.
+  // - string valueType: format the raw directly (e.g. the model type resolves provider/id → its
+  //   display label). coerceTypedValue is an identity for string valueTypes, so the raw is the value.
+  // - boolean: returned verbatim (its 'true'/'false' raw already equals its format output).
+  if (typeDef.valueType === "number") {
+    const coerced = coerceTypedValue(rawValue, typeDef);
+    return typeof coerced === "number" ? typeDef.format(coerced, ctx) : rawValue;
+  }
+  return typeDef.valueType === "string" ? typeDef.format(rawValue, ctx) : rawValue;
+}
+
+// ── Built-in parse helpers ──────────────────────────────────────────────────
+
+/**
+ * Parse an integer (the `number` type's parser). Accepts ANY integer — including negatives and
+ * zero — and does NOT floor/clamp; out-of-range rejection is the gate's job (7, via `min`/`max`),
+ * not the parser's.
+ */
+function parseInteger(input: string): number | undefined {
+  const trimmed = input.trim();
+  if (!/^-?\d+$/.test(trimmed)) return undefined;
+  return parseInt(trimmed, 10);
+}
+
+/**
+ * Parse a duration (the `duration` type's parser): human form via `parseHumanDuration`
+ * (e.g. "30s", "5m", "1d", "0s") with a bare-millisecond `Number(input)` fallback so a plain numeric
+ * string like "300000" still parses. Zero is a valid duration — range rejection (e.g. min > 0)
+ * is the gate's job (via `min`/`max`), not the parser's, matching the `number` type's contract.
+ * Negative/invalid → undefined.
+ */
+function parseDuration(input: string): number | undefined {
+  if (input.trim() === "") return undefined;
+  const ms = parseHumanDuration(input);
+  if (ms !== undefined && ms >= 0) return ms;
+  const num = Number(input);
+  if (!Number.isNaN(num) && num >= 0) return num;
+  return undefined;
+}
+
+/**
+ * Match a preset by its label OR its raw value. Shared membership check — both the
+ * compact-threshold parser and the thinking-level parser validate input against the effective
+ * presets rather than keeping their own copy of the values.
+ */
+function matchPresetValue(input: string, ctx: TypeContext): string | undefined {
+  for (const [label, value] of ctx.presets) {
+    if (label === input || String(value) === input) {
+      return value as string;
+    }
+  }
+  return undefined;
+}
+
+// ── The built-in TypeDefinitions ───────────────────────────────────────────
+
+const numberType: TypeDefinition<number> = {
+  id: "number",
+  valueType: "number",
+  parse: (input) => parseInteger(input),
+  format: (value) => String(value),
+  supportsCustomValues: true,
+  errorMessage: "Enter a whole number",
+  bounded: true,
+};
+
+const durationType: TypeDefinition<number> = {
+  id: "duration",
+  valueType: "number",
+  parse: (input) => parseDuration(input),
+  format: (value) => formatHumanDuration(value),
+  supportsCustomValues: true,
+  errorMessage: "Enter a duration (e.g. 30s, 5m, 7d)",
+  bounded: true,
+};
+
+/** Canonical off/force sentinels for the compact-threshold type — the "never" and "always"
+ *  states alongside the `compact>NK` "when exceeding" form. Identity-valued (label === value).
+ *  Recognized by {@link compactThresholdType}'s parse so a consumer can declare them as bare preset
+ *  strings (`presets: ["none", "compact", "compact>75K", ...]`). */
+const COMPACT_THRESHOLD_SENTINELS = new Set(["none", "compact"]);
+
+const compactThresholdType: TypeDefinition<string> = {
+  id: "compact-threshold",
+  valueType: "string",
+  parse: (input, ctx) => {
+    // 1. preset value (by label or raw value)
+    const preset = matchPresetValue(input, ctx);
+    if (preset !== undefined) return preset;
+    // 2. already-canonical compact>NK
+    if (isCompactThreshold(input)) return input;
+    // 3. canonical off/force sentinels (never / always)
+    if (COMPACT_THRESHOLD_SENTINELS.has(input)) return input;
+    // 4. numeric string → compact>NK
+    return parseCompactThreshold(input);
+  },
+  format: (value) => value,
+  toInputPrefill: (value) => formatCompactThreshold(value),
+  supportsCustomValues: true,
+  errorMessage: "Enter a compact threshold (e.g. 300)",
+};
+
+const stringType: TypeDefinition<string> = {
+  id: "string",
+  valueType: "string",
+  // Closed enum when effective presets exist: a value must match a preset's label OR raw value,
+  // else INVALID (the gate resets to default + logs). No presets → free-form identity (a value
+  // like baseBranch survives). Closed enums are ALSO enforced UI-side (supportsCustomValues: false).
+  parse: (input, ctx) => (ctx.presets.length > 0 ? matchPresetValue(input, ctx) : input),
+  format: (value) => value,
+  supportsCustomValues: false, // closed enums are enforced UI-side
+  errorMessage: "Select a value",
+};
+
+const booleanType: TypeDefinition<boolean> = {
+  id: "boolean",
+  valueType: "boolean",
+  parse: (input) => {
+    if (input === "true") return true;
+    if (input === "false") return false;
+    return undefined;
+  },
+  format: (value) => String(value),
+  supportsCustomValues: false,
+  errorMessage: "Select true or false",
+};
+
+// ── The thinking-level built-in ─────────────────────────────────────────────
+
+/**
+ * The six thinking levels, as `[label, value]` preset pairs (label equals value). The default
+ * `presets` for the `thinking-level` type — a consumer writes only `{ type: "thinking-level" }`
+ * and gets these without declaring `presets` (overridable per-setting: replace, not merge).
+ */
+export const THINKING_LEVEL_PRESETS = [
+  ["off", "off"],
+  ["minimal", "minimal"],
+  ["low", "low"],
+  ["medium", "medium"],
+  ["high", "high"],
+  ["xhigh", "xhigh"],
+] as const satisfies readonly PresetPair[];
+
+const thinkingLevelType: TypeDefinition<string> = {
+  id: "thinking-level",
+  valueType: "string",
+  // Membership check against the EFFECTIVE presets (the type-def default, or a per-setting
+  // override). An unknown level returns undefined → the load gate rejects it and falls back to
+  // the setting's defaultValue.
+  parse: (input, ctx) => matchPresetValue(input, ctx),
+  format: (value) => value,
+  presets: THINKING_LEVEL_PRESETS,
+  supportsCustomValues: false,
+  errorMessage: "Select a thinking level",
+};
+
+// ── The model built-in ───────────────────────────────────────────────────────
+
+/**
+ * Resolve a stored `"provider/id"` value to its display label via the captured registry. A stale
+ * id (one the registry has no record of) renders verbatim rather than failing. When no
+ * registry was captured, the raw value is returned unchanged (graceful — never dereferences an
+ * absent registry). The provider/id are split on the FIRST slash so an id containing a slash still
+ * resolves by its leading provider/id segments.
+ */
+function formatModelValue(value: string): string {
+  const parts = splitModelId(value);
+  if (!parts) return value;
+  const found = getCapturedCtx().modelRegistry?.find(parts.provider, parts.id);
+  return found ? modelLabel(found) : value;
+}
+
+const modelType: TypeDefinition<string> = {
+  id: "model",
+  valueType: "string",
+  // Identity parse — a provider/id (even a stale one) loads unchanged. Null is valid via the
+  // gate's null-preset path (the resolver's ['Default', null] pair), not via parse.
+  parse: (input) => input,
+  format: (value) => formatModelValue(value),
+  presets: resolveModelPresets,
+  supportsCustomValues: false,
+  errorMessage: "Select a model",
+};
+
+// Pre-register the 7 built-ins at module load.
+registerTypeDefinition(numberType);
+registerTypeDefinition(durationType);
+registerTypeDefinition(compactThresholdType);
+registerTypeDefinition(stringType);
+registerTypeDefinition(booleanType);
+registerTypeDefinition(thinkingLevelType);
+registerTypeDefinition(modelType);

package/src/ui/modal-frame.ts

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 avtc <tarasenkov@gmail.com>
+
+/**
+ * Simple modal frame renderer for pi TUI overlays.
+ *
+ * Provides title bar, side borders, and optional help text undertitle.
+ * Used internally by avtc-pi-settings-ui's openSettingsModal.
+ *
+ * Usage:
+ * ```ts
+ * const frame = new ModalFrame({
+ *   title: "My Dialog",
+ *   content: myContentComponent,
+ *   helpText: "Esc: close | Enter: confirm",
+ * });
+ * ```
+ */
+import type { Component } from "@earendil-works/pi-tui";
+
+// ── Border characters ──────────────────────────────────────────────────────────
+
+const ROUNDED = {
+  topLeft: "╭",
+  topRight: "╮",
+  bottomLeft: "╰",
+  bottomRight: "╯",
+  horizontal: "─",
+  vertical: "│",
+} as const;
+
+// ── Types ──────────────────────────────────────────────────────────────────────
+
+export interface ModalFrameOptions {
+  /** Title text displayed in the top border. */
+  title: string;
+  /** Optional right-aligned subtitle in the top border. */
+  titleRight?: string;
+  /** Nested content component rendered inside the frame. */
+  content: Component;
+  /** Optional help text displayed below the bottom border. */
+  helpText?: string;
+}
+
+// ── ModalFrame ─────────────────────────────────────────────────────────────────
+
+export class ModalFrame implements Component {
+  private options: ModalFrameOptions;
+
+  constructor(options: ModalFrameOptions) {
+    this.options = options;
+  }
+
+  invalidate(): void {
+    // ModalFrame has no internal state to invalidate
+  }
+
+  render(width: number): string[] {
+    const { title, titleRight, content, helpText } = this.options;
+    const b = ROUNDED;
+    const lines: string[] = [];
+
+    // ── Top border with title ──
+    const innerWidth = width - 2; // minus left and right border chars
+    const titleStr = title ? ` ${title} ` : "";
+    const titleRightStr = titleRight ? ` ${titleRight} ` : "";
+    const titleContentLen = titleStr.length + titleRightStr.length;
+    const fillLen = Math.max(0, innerWidth - titleContentLen);
+    const topLine = `${b.topLeft}${titleStr}${b.horizontal.repeat(fillLen)}${titleRightStr}${b.topRight}`;
+    // Pad/truncate to exact width
+    lines.push(padToWidth(topLine, width));
+
+    // ── Content ──
+    const contentWidth = Math.max(1, innerWidth);
+    const contentLines = content.render(contentWidth);
+    for (const line of contentLines) {
+      // Truncate content line to innerWidth, pad with spaces to fill
+      const inner = padToWidth(truncateToWidth(line, contentWidth), contentWidth);
+      lines.push(`${b.vertical}${inner}${b.vertical}`);
+    }
+
+    // ── Bottom border ──
+    lines.push(`${b.bottomLeft}${b.horizontal.repeat(innerWidth)}${b.bottomRight}`);
+
+    // ── Help text undertitle ──
+    if (helpText) {
+      lines.push(padToWidth(` ${helpText} `, width));
+    }
+
+    return lines;
+  }
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+/** Truncate a string to at most `maxWidth` visible (ANSI-aware) columns. */
+function truncateToWidth(text: string, maxWidth: number): string {
+  // Strip ANSI escape sequences for width measurement
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: legitimate ANSI escape handling
+  const stripped = text.replace(/\x1b\[[0-9;]*m/g, "");
+  if (stripped.length <= maxWidth) return text;
+  // Find cut point in original string where visible chars reach maxWidth
+  let visible = 0;
+  let i = 0;
+  let inEscape = false;
+  while (i < text.length && visible < maxWidth) {
+    if (text[i] === "\x1b") {
+      inEscape = true;
+      i++;
+      continue;
+    }
+    if (inEscape) {
+      if (text[i] === "m") inEscape = false;
+      i++;
+      continue;
+    }
+    visible++;
+    i++;
+  }
+  return text.slice(0, i);
+}
+
+/** Pad a string with spaces to exactly `width` visible columns. */
+function padToWidth(text: string, width: number): string {
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: legitimate ANSI escape handling
+  const stripped = text.replace(/\x1b\[[0-9;]*m/g, "");
+  const visibleLen = stripped.length;
+  if (visibleLen >= width) return text;
+  return text + " ".repeat(width - visibleLen);
+}

package/src/ui/picker-helpers.ts

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 avtc <tarasenkov@gmail.com>
+
+/**
+ * Shared helpers for the picker submenus (enum-picker, value-picker).
+ *
+ * Both pickers use the same cursor up/down wrap-around navigation and the
+ * same line-building loop; extracting these keeps them in sync.
+ */
+
+/** Move `index` by `delta` (−1 up, +1 down) within a list of `length` entries,
+ * wrapping at both ends. Returns the new index.
+ */
+export function wrapIndex(index: number, length: number, delta: number): number {
+  if (length <= 0) return 0;
+  return (index + delta + length) % length;
+}
+
+/** Cursor step deltas for wrapIndex(): up = previous, down = next. */
+const STEP_UP = -1;
+const STEP_DOWN = 1;
+
+/** Compute the visible window for a centered scrolling viewport (mirrors pi-tui's SelectList:
+ *  the selection stays centered until it nears the top/bottom, then the window pins to that edge).
+ *  Returns `{ start, end }` (half-open) clamped to `[0, length]`. When `length <= maxVisible` the
+ *  whole list fits and `{ start: 0, end: length }` is returned. */
+export function computeViewport(
+  selectedIndex: number,
+  length: number,
+  maxVisible: number,
+): { start: number; end: number } {
+  if (length <= 0) return { start: 0, end: 0 };
+  const start = Math.max(0, Math.min(selectedIndex - Math.floor(maxVisible / 2), length - maxVisible));
+  const end = Math.min(start + maxVisible, length);
+  return { start, end };
+}
+
+/** Build a single picker line: cursor prefix (or 2-space indent) + the themed label (selected vs unselected). */
+export function renderPickerLine(
+  isSelected: boolean,
+  theme: { cursor: string },
+  selectedLabel: string,
+  unselectedLabel: string,
+): string {
+  const prefix = isSelected ? theme.cursor : "  ";
+  const label = isSelected ? selectedLabel : unselectedLabel;
+  return prefix + label;
+}
+
+/** Keybinding shape used by handlePickerNavigation (subset of pi-tui KeybindingsManager). */
+interface KeybindingMatcher {
+  matches(data: string, action: string): boolean;
+}
+
+/**
+ * Handle cursor up/down navigation for a picker. Returns the new wrapped index when an up/down key
+ * is matched, or `undefined` when the input is not a navigation key (caller handles confirm/cancel/etc).
+ */
+export function handlePickerNavigation(
+  kb: KeybindingMatcher,
+  data: string,
+  selectedIndex: number,
+  length: number,
+): number | undefined {
+  if (kb.matches(data, "tui.select.up")) return wrapIndex(selectedIndex, length, STEP_UP);
+  if (kb.matches(data, "tui.select.down")) return wrapIndex(selectedIndex, length, STEP_DOWN);
+  return undefined;
+}

package/src/ui/schema-tabs.ts

@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 avtc <tarasenkov@gmail.com>
+
+/**
+ * Schema-driven tab group builder.
+ *
+ * Converts a SettingsSchema + current settings values into the TabDefinition[]
+ * format expected by SettingsTabsModal. Handles display formatting for all
+ * setting types (durations, compact thresholds, presetLabels mapping, etc).
+ */
+
+import {
+  buildPresetItems,
+  buildPresetItemsFromPairs,
+  computeRawInternalValue,
+  resolveEffectivePresets,
+  resolveNullLabelFromPairs,
+} from "../normalization.js";
+import type { PresetItem, PresetPair, SettingItem, SettingSchema, SettingsSchema, TabDefinition } from "../schema.js";
+import { formatRawForDisplay, getTypeDefinition, type TypeContext } from "../type-definitions.js";
+
+/**
+ * Format a raw internal value for display in the settings list.
+ * Display formatting is `getTypeDefinition(type).format` — the old type-discriminant switch (whose
+ * `default` returned raw ms) is gone, so a `duration` value renders as `"30s"`, not `"30000"`.
+ * Preset-matched values (the `"Infinite"`/`"Never"` preset labels) are still resolved by the
+ * preset-label map at the top — unaffected.
+ */
+function formatSettingDisplay(rawValue: string, settingType: string, presets: readonly PresetItem[]): string {
+  if (rawValue === "") return rawValue;
+
+  // Map a raw internal value to its preset label.
+  if (presets.length) {
+    const match = presets.find((p) => p.displayValue === rawValue);
+    if (match) return match.label;
+  }
+
+  const typeDef = getTypeDefinition(settingType);
+  // Build a minimal TypeContext (format rarely needs it; compact-threshold format is identity).
+  const ctx: TypeContext = { presets: presets.map((p): PresetPair => [p.label, p.rawValue]) };
+
+  // Format the raw value for display (coerce → typeof-number-guard → format). Shared with
+  // value-picker so the NaN guard can't drift between the two display paths.
+  return formatRawForDisplay(rawValue, typeDef, ctx);
+}
+
+/**
+ * Memoized cohesive preset list per setting schema.
+ * Schemas are immutable references, so WeakMap lets us compute the PresetItem[] once
+ * per schema instead of on every interactive rebuild (arrow-key nav, value change).
+ * Only STATIC-array effective presets are cached: resolved function-presets are fresh per
+ * modal-open (the live model list changes between opens), so they bypass this cache.
+ */
+const presetsCache = new WeakMap<SettingSchema, readonly PresetItem[]>();
+
+/**
+ * Build tab groups from a schema + current settings values.
+ * Returns TabDefinition[] compatible with SettingsTabsModal.
+ *
+ * `resolvedPairs` carries the function-presets resolved once at modal-open (the model
+ * resolver's live list). Pass `null` for callers without a modal (static-array presets
+ * render from the WeakMap cache; function-presets settings render with an empty list).
+ */
+export function buildSchemaTabGroups(
+  settings: Record<string, unknown>,
+  schema: SettingsSchema,
+  resolvedPairs: Map<string, PresetPair[]> | null,
+): TabDefinition[] {
+  const pairsMap = resolvedPairs;
+
+  /**
+   * Preset items for a setting. Static-array sources read the WeakMap cache; function
+   * sources read the per-open resolved map fresh (never cached — the model list changes
+   * between opens). If a resolver returned no pairs (threw/rejected), the list is empty.
+   */
+  const getPresets = (
+    setting: SettingSchema,
+    eff: ReturnType<typeof resolveEffectivePresets>,
+  ): readonly PresetItem[] => {
+    if (eff.isFunction) {
+      const pairs = pairsMap?.get(setting.id) ?? [];
+      return buildPresetItemsFromPairs(pairs);
+    }
+    let cached = presetsCache.get(setting);
+    if (!cached) {
+      cached = buildPresetItems(setting);
+      presetsCache.set(setting, cached);
+    }
+    return cached;
+  };
+
+  const result: TabDefinition[] = [];
+  // Build O(1) lookup map for settings by id
+  const settingMap = new Map(schema.settings.map((s) => [s.id, s]));
+
+  for (const tabDef of schema.tabs) {
+    const items: SettingItem[] = [];
+
+    for (const settingId of tabDef.settingIds) {
+      const settingSchema = settingMap.get(settingId);
+      if (!settingSchema) continue;
+
+      const eff = resolveEffectivePresets(settingSchema);
+      const presetItems = getPresets(settingSchema, eff);
+      let rawValue = computeRawInternalValue(settings, settingSchema);
+
+      // A function-presets setting derives its null label from the resolved pairs (e.g. the
+      // model resolver's ["Default", null]): when the value is null/undefined (the static
+      // "Infinite" fallback), override it with the resolved null label so a null model shows
+      // "Default". Checks the structural value (not the display string) so a literal "Infinite"
+      // string value is never mistaken for a null.
+      if (eff.isFunction) {
+        const original = settings[settingSchema.id];
+        if ((original === null || original === undefined) && pairsMap?.has(settingSchema.id)) {
+          const resolvedNull = resolveNullLabelFromPairs(pairsMap.get(settingSchema.id) ?? []);
+          if (resolvedNull) rawValue = resolvedNull;
+        }
+      }
+
+      const displayValue = formatSettingDisplay(rawValue, settingSchema.type, presetItems);
+
+      items.push({
+        id: settingSchema.id,
+        label: settingSchema.label,
+        value: rawValue,
+        displayValue,
+        type: settingSchema.type,
+        description: settingSchema.description,
+        presets: presetItems,
+      });
+    }
+
+    result.push({
+      label: tabDef.label,
+      settings: items,
+    });
+  }
+
+  return result;
+}