@nextclaw/ui 0.14.0 → 0.14.1-beta.0

package/src/features/chat/managers/__tests__/chat-run.manager.test.ts

@@ -1,4 +1,5 @@
 import type { NcpMessage } from '@nextclaw/ncp';
+import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
 import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
@@ -75,6 +76,39 @@ describe('ChatRunManager', () => {
     expect(uiManager.goToSession).toHaveBeenCalledWith('materialized-session', { replace: true });
   });
 
+  it('keeps the runtime-default sentinel in request metadata to override stale session model metadata', async () => {
+    const { manager } = createChatRunManager();
+    const sendEnvelope = vi.fn(async () => ({
+      sessionId: 'session-1',
+      userMessageId: 'user-message-1',
+      assistantMessageId: null,
+      runId: 'run-1',
+    }));
+    manager.setActiveRuntime({
+      sessionKey: 'session-1',
+      sendEnvelope,
+      abortCurrentRun: vi.fn(),
+      resumeCurrentSessionRun: vi.fn(),
+    });
+
+    await manager.sendMessage({
+      message: 'hello',
+      sessionKey: 'session-1',
+      agentId: 'main',
+      sessionType: 'codex',
+      model: RUNTIME_DEFAULT_MODEL_VALUE,
+    });
+
+    expect(sendEnvelope).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metadata: expect.objectContaining({
+          model: RUNTIME_DEFAULT_MODEL_VALUE,
+          preferred_model: RUNTIME_DEFAULT_MODEL_VALUE,
+        }),
+      }),
+    );
+  });
+
   it('does not send through a runtime for another session', async () => {
     const { manager } = createChatRunManager();
     const sendEnvelope = vi.fn();

package/src/features/chat/managers/__tests__/chat-session-preference-sync.manager.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
+import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
 import { updateNcpSession } from '@/shared/lib/api';
-import { ChatSessionPreferenceSync } from '../chat-session-preference-sync.manager';
+import { ChatSessionPreferenceSync } from '@/features/chat/managers/chat-session-preference-sync.manager';
 import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
@@ -25,6 +26,7 @@ describe('ChatSessionPreferenceSync', () => {
     useChatInputStore.setState((state) => ({
       snapshot: {
         ...state.snapshot,
+        modelOptions: [],
         selectedModel: '',
         selectedThinkingLevel: null
       }
@@ -74,4 +76,144 @@ describe('ChatSessionPreferenceSync', () => {
       });
     });
   });
+
+  it('clears the persisted model preference when runtime default is selected', async () => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        selectedModel: RUNTIME_DEFAULT_MODEL_VALUE,
+        selectedThinkingLevel: null
+      }
+    }));
+    useChatSessionListStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        selectedSessionKey: 'session-1'
+      }
+    }));
+    useChatThreadStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        canDeleteSession: true
+      }
+    }));
+
+    const sync = new ChatSessionPreferenceSync(updateNcpSession);
+    sync.syncSelectedSessionPreferences();
+    await vi.waitFor(() => {
+      expect(updateNcpSession).toHaveBeenCalledWith('session-1', {
+        preferredModel: null,
+        preferredThinking: null
+      });
+    });
+  });
+
+  it('uses the runtime-default thinking capability default when no session thinking is persisted', () => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        modelOptions: [
+          {
+            value: RUNTIME_DEFAULT_MODEL_VALUE,
+            modelLabel: 'Runtime default',
+            providerLabel: '',
+            isRuntimeDefault: true,
+            thinkingCapability: {
+              supported: ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'],
+              default: 'high',
+            },
+          },
+        ],
+        selectedModel: '',
+        selectedThinkingLevel: null,
+      }
+    }));
+
+    const sync = new ChatSessionPreferenceSync(updateNcpSession);
+    sync.syncInputSelection({
+      selectedSessionExists: true,
+      defaultModel: RUNTIME_DEFAULT_MODEL_VALUE,
+      selectedSessionPreferredThinking: null,
+      fallbackPreferredThinking: null,
+    });
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      selectedModel: RUNTIME_DEFAULT_MODEL_VALUE,
+      selectedThinkingLevel: 'high',
+    });
+  });
+
+  it('does not rewrite the input snapshot when the resolved selection is unchanged', () => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        modelOptions: [
+          {
+            value: 'openai/gpt-5',
+            modelLabel: 'GPT-5',
+            providerLabel: 'OpenAI',
+            thinkingCapability: null,
+          },
+        ],
+        selectedModel: 'openai/gpt-5',
+        selectedThinkingLevel: null,
+      }
+    }));
+    const sync = new ChatSessionPreferenceSync(updateNcpSession);
+    const listener = vi.fn();
+    const unsubscribe = useChatInputStore.subscribe(listener);
+
+    sync.syncInputSelection({
+      selectedSessionExists: true,
+      selectedSessionPreferredModel: 'openai/gpt-5',
+      selectedSessionPreferredThinking: null,
+    });
+
+    unsubscribe();
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('applies a historical session preferred model after its summary arrives', () => {
+    useChatInputStore.setState((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        modelOptions: [
+          {
+            value: 'anthropic/claude-sonnet-4',
+            modelLabel: 'Claude Sonnet 4',
+            providerLabel: 'Anthropic',
+            thinkingCapability: null,
+          },
+          {
+            value: 'openai/gpt-5',
+            modelLabel: 'GPT-5',
+            providerLabel: 'OpenAI',
+            thinkingCapability: null,
+          },
+        ],
+        selectedModel: 'anthropic/claude-sonnet-4',
+        selectedThinkingLevel: null,
+      }
+    }));
+    const sync = new ChatSessionPreferenceSync(updateNcpSession);
+
+    sync.syncInputSelection({
+      selectedSessionKey: 'session-2',
+      selectedSessionExists: false,
+      fallbackPreferredModel: 'anthropic/claude-sonnet-4',
+    });
+    expect(useChatInputStore.getState().snapshot.selectedModel).toBe(
+      'anthropic/claude-sonnet-4',
+    );
+
+    sync.syncInputSelection({
+      selectedSessionKey: 'session-2',
+      selectedSessionExists: true,
+      selectedSessionPreferredModel: 'openai/gpt-5',
+      selectedSessionPreferredThinking: null,
+      fallbackPreferredModel: 'anthropic/claude-sonnet-4',
+    });
+
+    expect(useChatInputStore.getState().snapshot.selectedModel).toBe('openai/gpt-5');
+  });
 });

package/src/features/chat/managers/__tests__/chat-thread.manager.test.ts

@@ -483,6 +483,7 @@ describe('ChatThreadManager showContent', () => {
       },
       title: 'Example URL',
       purpose: 'read',
+      placement: undefined,
     });
     await manager.handleUiShowContentEvent({
       id: 'tool:call-show-content-1:show-content',
@@ -495,6 +496,7 @@ describe('ChatThreadManager showContent', () => {
       },
       title: 'Example URL',
       purpose: 'read',
+      placement: undefined,
     });
 
     expect(uiManager.showContent).toHaveBeenCalledTimes(1);
@@ -541,6 +543,34 @@ describe('ChatThreadManager showContent', () => {
       title: 'Reader',
     });
   });
+
+});
+
+describe('ChatThreadManager inline showContent', () => {
+  it('does not auto-open inline panel app content outside the message card', async () => {
+    const uiManager = createUiManager();
+    const manager = new ChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof ChatThreadManager>[1],
+      {} as ConstructorParameters<typeof ChatThreadManager>[2],
+    );
+
+    await manager.handleUiShowContentEvent({
+      id: 'tool:call-show-content-inline:show-content',
+      toolCallId: 'call-show-content-inline',
+      target: {
+        type: 'panel_app',
+        payload: {
+          appId: 'reader',
+        },
+      },
+      title: 'Reader',
+      purpose: 'interact',
+      placement: 'inline',
+    });
+
+    expect(uiManager.showContent).not.toHaveBeenCalled();
+  });
 });
 
 describe('ChatThreadManager visible workspace selection', () => {

package/src/features/chat/managers/__tests__/recent-selection.manager.test.ts

@@ -1,22 +1,16 @@
-import { RecentSelectionManager } from '../recent-selection.manager';
+import { RecentSelectionManager } from '@/features/chat/managers/recent-selection.manager';
+import { useRecentSelectionStore } from '@/features/chat/stores/recent-selection.store';
 
 describe('RecentSelectionManager', () => {
   const storageKey = 'test.recent-selection-manager';
-  let storageState: Record<string, string>;
-  let storage: Pick<Storage, 'getItem' | 'setItem'>;
 
   beforeEach(() => {
-    storageState = {};
-    storage = {
-      getItem: (key) => storageState[key] ?? null,
-      setItem: (key, value) => {
-        storageState[key] = value;
-      }
-    };
+    window.localStorage.clear();
+    useRecentSelectionStore.setState({ entriesByKey: {} });
   });
 
   it('stores recent values in LRU order and respects the size limit', () => {
-    const manager = new RecentSelectionManager({ storageKey, limit: 3, storage });
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
 
     manager.remember('openai/gpt-5');
     manager.remember('anthropic/claude-sonnet-4');
@@ -31,7 +25,7 @@ describe('RecentSelectionManager', () => {
   });
 
   it('filters recent values by the currently available list and threshold', () => {
-    const manager = new RecentSelectionManager({ storageKey, limit: 4, storage });
+    const manager = new RecentSelectionManager({ storageKey, limit: 4 });
     manager.remember('openai/gpt-5');
     manager.remember('anthropic/claude-sonnet-4');
     manager.remember('missing/model');
@@ -60,9 +54,38 @@ describe('RecentSelectionManager', () => {
   });
 
   it('returns an empty list when storage content is malformed', () => {
-    storageState[storageKey] = '{broken-json';
-    const manager = new RecentSelectionManager({ storageKey, limit: 3, storage });
+    window.localStorage.setItem(storageKey, '{broken-json');
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
 
     expect(manager.read()).toEqual([]);
   });
+
+  it('does not mutate an empty store while reading recent values', () => {
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
+
+    expect(manager.read()).toEqual([]);
+    expect(useRecentSelectionStore.getState().entriesByKey).toEqual({});
+  });
+
+  it('keeps namespaced recent values separate from the global list', () => {
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
+
+    manager.remember('openai/gpt-5');
+    manager.remember('anthropic/claude-sonnet-4', { namespace: 'codex' });
+    manager.remember('minimax/MiniMax-M2.7', { namespace: 'hermes' });
+    manager.remember('openai/gpt-5.1', { namespace: 'codex' });
+
+    expect(manager.read()).toEqual(['openai/gpt-5']);
+    expect(manager.read({ namespace: 'codex' })).toEqual([
+      'openai/gpt-5.1',
+      'anthropic/claude-sonnet-4'
+    ]);
+    expect(
+      manager.resolveVisible({
+        namespace: 'hermes',
+        availableValues: ['minimax/MiniMax-M2.7', 'openai/gpt-5'],
+        minAvailableCount: 0
+      })
+    ).toEqual(['minimax/MiniMax-M2.7']);
+  });
 });

package/src/features/chat/managers/chat-draft-intent.manager.ts

@@ -0,0 +1,46 @@
+export type ChatDraftIntent = {
+  id: number;
+  prompt: string;
+};
+
+type ChatDraftIntentListener = (intent: ChatDraftIntent) => void;
+
+export class ChatDraftIntentManager {
+  private nextId = 0;
+  private pendingIntent: ChatDraftIntent | null = null;
+  private readonly listeners = new Set<ChatDraftIntentListener>();
+
+  requestDraft = (prompt: string) => {
+    const normalizedPrompt = prompt.trim();
+    if (!normalizedPrompt) {
+      return;
+    }
+    const intent: ChatDraftIntent = {
+      id: this.nextId + 1,
+      prompt: normalizedPrompt,
+    };
+    this.nextId = intent.id;
+    this.pendingIntent = intent;
+    this.listeners.forEach((listener) => listener(intent));
+  };
+
+  consumePending = (): ChatDraftIntent | null => {
+    const intent = this.pendingIntent;
+    this.pendingIntent = null;
+    return intent;
+  };
+
+  markConsumed = (intentId: number) => {
+    if (this.pendingIntent?.id !== intentId) {
+      return;
+    }
+    this.pendingIntent = null;
+  };
+
+  subscribe = (listener: ChatDraftIntentListener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+}

package/src/features/chat/managers/chat-input.manager.ts

@@ -31,9 +31,6 @@ import { systemStatusManager } from '@/features/system-status';
 import { shouldClearPendingProjectRootOverride } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
 
 function resolveModelForSend(value: string): string | undefined {
-  if (isRuntimeDefaultModelValue(value)) {
-    return undefined;
-  }
   return value || undefined;
 }
 
@@ -55,16 +52,6 @@ export class ChatInputManager {
     private sessionListManager: ChatSessionListManager
   ) {}
 
-  private hasSnapshotChanges = (patch: Partial<ChatInputSnapshot>): boolean => {
-    const current = useChatInputStore.getState().snapshot;
-    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatInputSnapshot, ChatInputSnapshot[keyof ChatInputSnapshot]]>) {
-      if (!Object.is(current[key], value)) {
-        return true;
-      }
-    }
-    return false;
-  };
-
   private resolveUpdateValue = <T>(prev: T, next: SetStateAction<T>): T => {
     if (typeof next === 'function') {
       return (next as (value: T) => T)(prev);
@@ -75,6 +62,16 @@ export class ChatInputManager {
   private isSameStringArray = (left: string[], right: string[]): boolean =>
     left.length === right.length && left.every((value, index) => value === right[index]);
 
+  private hasSnapshotChanges = (patch: Partial<ChatInputSnapshot>): boolean => {
+    const current = useChatInputStore.getState().snapshot;
+    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatInputSnapshot, ChatInputSnapshot[keyof ChatInputSnapshot]]>) {
+      if (!Object.is(current[key], value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
   private isRuntimeBlockedForSend = (): boolean =>
     isNcpChatRuntimeBlocked(systemStatusManager.getStatusView());
 
@@ -351,6 +348,9 @@ export class ChatInputManager {
 
   selectModel = (value: string) => {
     this.setSelectedModel(value);
+    chatRecentModelsManager.remember(value, {
+      namespace: useChatInputStore.getState().snapshot.selectedSessionType,
+    });
     if (!isRuntimeDefaultModelValue(value)) {
       chatRecentModelsManager.remember(value);
     }

package/src/features/chat/managers/chat-run.manager.ts

@@ -61,6 +61,8 @@ export class ChatRunManager {
 
   applyRunSnapshot = (snapshot: ChatRunSnapshot) => {
     const isSending = snapshot.isSending || snapshot.isRunning;
+    const sessionKey =
+      snapshot.routeSessionKey ?? snapshot.materializedSessionKey ?? null;
     useChatInputStore.getState().setSnapshot({
       canStopGeneration: snapshot.isRunning,
       stopDisabledReason: snapshot.isRunning ? null : '__preparing__',
@@ -70,6 +72,7 @@ export class ChatRunManager {
       isSending,
     });
     useChatThreadStore.getState().setSnapshot({
+      sessionKey,
       isHistoryLoading: snapshot.isHydrating,
       messages: snapshot.visibleMessages,
       isSending,

package/src/features/chat/managers/chat-session-preference-sync.manager.ts

@@ -45,6 +45,7 @@ export class ChatSessionPreferenceSync {
   };
 
   syncInputSelection = (params: {
+    selectedSessionKey?: string | null;
     selectedSessionExists: boolean;
     selectedSessionPreferredModel?: string;
     fallbackPreferredModel?: string;
@@ -56,15 +57,14 @@ export class ChatSessionPreferenceSync {
       defaultModel,
       fallbackPreferredModel,
       fallbackPreferredThinking,
+      selectedSessionKey = null,
       selectedSessionExists,
       selectedSessionPreferredModel,
       selectedSessionPreferredThinking,
     } = params;
     const { snapshot } = useChatInputStore.getState();
     const { modelOptions } = snapshot;
-    const selectedSessionKey = useChatThreadStore.getState().snapshot.sessionKey;
     const sessionChanged = this.previousPreferenceSessionKey !== selectedSessionKey;
-    this.previousPreferenceSessionKey = selectedSessionKey;
     const preserveCurrentPreference = sessionChanged && Boolean(selectedSessionKey) && !selectedSessionExists;
     const selectedModel = resolveSelectedModelValue({
       currentSelectedModel: snapshot.selectedModel,
@@ -88,10 +88,27 @@ export class ChatSessionPreferenceSync {
       preferSessionPreferredThinking: sessionChanged,
       preserveCurrentSelectedThinkingOnSessionChange: preserveCurrentPreference,
     });
+    if (
+      snapshot.selectedModel === selectedModel &&
+      snapshot.selectedThinkingLevel === selectedThinking
+    ) {
+      this.recordSyncedPreferenceSessionKey(selectedSessionKey, selectedSessionExists);
+      return;
+    }
     useChatInputStore.getState().setSnapshot({
       selectedModel,
       selectedThinkingLevel: selectedThinking,
     });
+    this.recordSyncedPreferenceSessionKey(selectedSessionKey, selectedSessionExists);
+  };
+
+  private recordSyncedPreferenceSessionKey = (
+    selectedSessionKey: string | null,
+    selectedSessionExists: boolean,
+  ): void => {
+    if (!selectedSessionKey || selectedSessionExists) {
+      this.previousPreferenceSessionKey = selectedSessionKey;
+    }
   };
 
   private enqueue = (next: QueuedSessionPreferenceSync): void => {

package/src/features/chat/managers/chat-thread.manager.ts

@@ -296,10 +296,14 @@ export class ChatThreadManager {
       target: payload.target,
       title: payload.title,
       purpose: payload.purpose,
+      placement: payload.placement,
     });
   };
 
   private showContent = async (request: ChatUiShowContentRequest): Promise<void> => {
+    if (request.placement === 'inline') {
+      return;
+    }
     if (request.target.type === 'file') {
       this.openFilePreview({
         path: request.target.payload.path,

package/src/features/chat/managers/chat-ui.manager.ts

@@ -6,6 +6,7 @@ import {
   createPanelAppResourceUri,
   createPanelAppRightPanelResourceTarget,
 } from '@/features/right-panel-resources';
+import { findPanelAppEntryByDisplayId } from '@/features/panel-apps';
 import type { DocBrowserManager } from '@/shared/components/doc-browser/managers/doc-browser.manager';
 import { nextclawClient, type PanelAppEntryView } from '@/shared/lib/api';
 
@@ -26,11 +27,6 @@ type ChatUiDisplayContentTarget = Extract<ChatUiShowContentRequest['target'], {
 
 const noopConfirm: ChatUiActions['confirm'] = async () => false;
 
-function isPanelAppEntryMatch(entry: PanelAppEntryView, value: string): boolean {
-  const normalizedValue = value.trim();
-  return [entry.id, entry.appId, entry.fileName, entry.title].some((candidate) => candidate.trim() === normalizedValue);
-}
-
 export class ChatUiManager {
   private state: ChatUiState = {
     pathname: ''
@@ -84,7 +80,7 @@ export class ChatUiManager {
       return null;
     }
     try {
-      return (await nextclawClient.panelApps.listPanelApps()).entries.find((entry) => isPanelAppEntryMatch(entry, normalizedValue)) ?? null;
+      return findPanelAppEntryByDisplayId((await nextclawClient.panelApps.listPanelApps()).entries, normalizedValue);
     } catch {
       return null;
     }

package/src/features/chat/managers/recent-selection.manager.ts

@@ -1,49 +1,51 @@
+import {
+  useRecentSelectionStore,
+  normalizeRecentSelectionList,
+  normalizeRecentSelectionValue,
+  resolveRecentSelectionKey,
+  type RecentSelectionScope,
+} from '@/features/chat/stores/recent-selection.store';
+
 type RecentSelectionManagerOptions = {
   storageKey: string;
   limit: number;
-  storage?: Pick<Storage, 'getItem' | 'setItem'> | null;
 };
 
 type VisibleRecentSelectionParams = {
   availableValues: string[];
   minAvailableCount: number;
   limit?: number;
-};
+} & RecentSelectionScope;
 
 export class RecentSelectionManager {
   constructor(private readonly options: RecentSelectionManagerOptions) {}
 
-  read = (): string[] => {
-    const storage = this.getStorage();
-    if (!storage) {
-      return [];
-    }
-    try {
-      return this.normalizeList(JSON.parse(storage.getItem(this.options.storageKey) ?? '[]'));
-    } catch {
-      return [];
-    }
+  read = (scope: RecentSelectionScope = {}): string[] => {
+    const key = resolveRecentSelectionKey(this.options, scope);
+    return normalizeRecentSelectionList(useRecentSelectionStore.getState().entriesByKey[key], this.options.limit);
   };
 
-  remember = (value: string): string[] => {
-    const normalizedValue = this.normalizeValue(value);
+  remember = (value: string, scope: RecentSelectionScope = {}): string[] => {
+    const normalizedValue = normalizeRecentSelectionValue(value);
     if (!normalizedValue) {
-      return this.read();
+      return this.read(scope);
     }
-    const next = [normalizedValue, ...this.read().filter((item) => item !== normalizedValue)].slice(0, this.options.limit);
-    this.write(next);
+    const key = resolveRecentSelectionKey(this.options, scope);
+    const next = [normalizedValue, ...this.read(scope).filter((item) => item !== normalizedValue)]
+      .slice(0, this.options.limit);
+    useRecentSelectionStore.getState().setEntries(key, next);
     return next;
   };
 
   resolveVisible = (params: VisibleRecentSelectionParams): string[] => {
-    const availableValues = this.normalizeList(params.availableValues, Number.POSITIVE_INFINITY);
+    const availableValues = normalizeRecentSelectionList(params.availableValues, Number.POSITIVE_INFINITY);
     if (availableValues.length <= params.minAvailableCount) {
       return [];
     }
     const availableSet = new Set(availableValues);
     const visible: string[] = [];
     const maxVisibleItems = Math.max(1, params.limit ?? this.options.limit);
-    for (const value of this.read()) {
+    for (const value of this.read(params)) {
       if (!availableSet.has(value) || visible.includes(value)) {
         continue;
       }
@@ -54,52 +56,4 @@ export class RecentSelectionManager {
     }
     return visible;
   };
-
-  private write = (values: string[]): void => {
-    const storage = this.getStorage();
-    if (!storage) {
-      return;
-    }
-    try {
-      storage.setItem(this.options.storageKey, JSON.stringify(this.normalizeList(values)));
-    } catch {
-      // Ignore storage write failures and keep the runtime behavior deterministic.
-    }
-  };
-
-  private getStorage = (): Storage | null => {
-    if (Object.prototype.hasOwnProperty.call(this.options, 'storage')) {
-      return (this.options.storage as Storage | null | undefined) ?? null;
-    }
-    if (typeof window === 'undefined') {
-      return null;
-    }
-    return window.localStorage;
-  };
-
-  private normalizeList = (values: unknown, limit = this.options.limit): string[] => {
-    if (!Array.isArray(values)) {
-      return [];
-    }
-    const deduped: string[] = [];
-    for (const value of values) {
-      const normalized = this.normalizeValue(value);
-      if (!normalized || deduped.includes(normalized)) {
-        continue;
-      }
-      deduped.push(normalized);
-      if (deduped.length >= limit) {
-        break;
-      }
-    }
-    return deduped;
-  };
-
-  private normalizeValue = (value: unknown): string | null => {
-    if (typeof value !== 'string') {
-      return null;
-    }
-    const normalized = value.trim();
-    return normalized.length > 0 ? normalized : null;
-  };
 }