diff --git a/src/application/Context/State/CategoryCollectionState.ts b/src/application/Context/State/CategoryCollectionState.ts
index 09efaf3a..c8a9936d 100644
--- a/src/application/Context/State/CategoryCollectionState.ts
+++ b/src/application/Context/State/CategoryCollectionState.ts
@@ -1,7 +1,7 @@
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { OperatingSystem } from '@/domain/OperatingSystem';
-import { UserFilter } from './Filter/UserFilter';
-import { IUserFilter } from './Filter/IUserFilter';
+import { AdaptiveFilterContext } from './Filter/AdaptiveFilterContext';
+import { FilterContext } from './Filter/FilterContext';
 import { ApplicationCode } from './Code/ApplicationCode';
 import { UserSelection } from './Selection/UserSelection';
 import { ICategoryCollectionState } from './ICategoryCollectionState';
@@ -15,7 +15,7 @@ export class CategoryCollectionState implements ICategoryCollectionState {
 
   public readonly selection: UserSelection;
 
-  public readonly filter: IUserFilter;
+  public readonly filter: FilterContext;
 
   public constructor(
     public readonly collection: ICategoryCollection,
@@ -45,7 +45,7 @@ const DefaultSelectionFactory: SelectionFactory = (
 ) => new UserSelectionFacade(...params);
 
 export type FilterFactory = (
-  ...params: ConstructorParameters<typeof UserFilter>
-) => IUserFilter;
+  ...params: ConstructorParameters<typeof AdaptiveFilterContext>
+) => FilterContext;
 
-const DefaultFilterFactory: FilterFactory = (...params) => new UserFilter(...params);
+const DefaultFilterFactory: FilterFactory = (...params) => new AdaptiveFilterContext(...params);
diff --git a/src/application/Context/State/Filter/AdaptiveFilterContext.ts b/src/application/Context/State/Filter/AdaptiveFilterContext.ts
new file mode 100644
index 00000000..1a498f61
--- /dev/null
+++ b/src/application/Context/State/Filter/AdaptiveFilterContext.ts
@@ -0,0 +1,35 @@
+import { EventSource } from '@/infrastructure/Events/EventSource';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { FilterResult } from './Result/FilterResult';
+import { FilterContext } from './FilterContext';
+import { FilterChangeDetails } from './Event/FilterChangeDetails';
+import { FilterChange } from './Event/FilterChange';
+import { FilterStrategy } from './Strategy/FilterStrategy';
+import { LinearFilterStrategy } from './Strategy/LinearFilterStrategy';
+
+export class AdaptiveFilterContext implements FilterContext {
+  public readonly filterChanged = new EventSource<FilterChangeDetails>();
+
+  public currentFilter: FilterResult | undefined;
+
+  constructor(
+    private readonly collection: ICategoryCollection,
+    private readonly filterStrategy: FilterStrategy = new LinearFilterStrategy(),
+  ) {
+
+  }
+
+  public applyFilter(filter: string): void {
+    if (!filter) {
+      throw new Error('Filter must be defined and not empty. Use clearFilter() to remove the filter');
+    }
+    const result = this.filterStrategy.applyFilter(filter, this.collection);
+    this.currentFilter = result;
+    this.filterChanged.notify(FilterChange.forApply(this.currentFilter));
+  }
+
+  public clearFilter(): void {
+    this.currentFilter = undefined;
+    this.filterChanged.notify(FilterChange.forClear());
+  }
+}
diff --git a/src/application/Context/State/Filter/Event/FilterChange.ts b/src/application/Context/State/Filter/Event/FilterChange.ts
index bed54dc8..c4c0ffbd 100644
--- a/src/application/Context/State/Filter/Event/FilterChange.ts
+++ b/src/application/Context/State/Filter/Event/FilterChange.ts
@@ -1,24 +1,24 @@
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { FilterActionType } from './FilterActionType';
 import {
-  IFilterChangeDetails, IFilterChangeDetailsVisitor,
+  FilterChangeDetails, FilterChangeDetailsVisitor,
   ApplyFilterAction, ClearFilterAction,
-} from './IFilterChangeDetails';
+} from './FilterChangeDetails';
 
-export class FilterChange implements IFilterChangeDetails {
+export class FilterChange implements FilterChangeDetails {
   public static forApply(
-    filter: IFilterResult,
-  ): IFilterChangeDetails {
+    filter: FilterResult,
+  ): FilterChangeDetails {
     return new FilterChange({ type: FilterActionType.Apply, filter });
   }
 
-  public static forClear(): IFilterChangeDetails {
+  public static forClear(): FilterChangeDetails {
     return new FilterChange({ type: FilterActionType.Clear });
   }
 
   private constructor(public readonly action: ApplyFilterAction | ClearFilterAction) { }
 
-  public visit(visitor: IFilterChangeDetailsVisitor): void {
+  public visit(visitor: FilterChangeDetailsVisitor): void {
     switch (this.action.type) {
       case FilterActionType.Apply:
         if (visitor.onApply) {
diff --git a/src/application/Context/State/Filter/Event/FilterChangeDetails.ts b/src/application/Context/State/Filter/Event/FilterChangeDetails.ts
new file mode 100644
index 00000000..58462505
--- /dev/null
+++ b/src/application/Context/State/Filter/Event/FilterChangeDetails.ts
@@ -0,0 +1,23 @@
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import type { FilterActionType } from './FilterActionType';
+
+export interface FilterChangeDetails {
+  readonly action: FilterAction;
+  visit(visitor: FilterChangeDetailsVisitor): void;
+}
+
+export interface FilterChangeDetailsVisitor {
+  readonly onClear?: () => void;
+  readonly onApply?: (filter: FilterResult) => void;
+}
+
+export type ApplyFilterAction = {
+  readonly type: FilterActionType.Apply,
+  readonly filter: FilterResult;
+};
+
+export type ClearFilterAction = {
+  readonly type: FilterActionType.Clear,
+};
+
+export type FilterAction = ApplyFilterAction | ClearFilterAction;
diff --git a/src/application/Context/State/Filter/Event/IFilterChangeDetails.ts b/src/application/Context/State/Filter/Event/IFilterChangeDetails.ts
deleted file mode 100644
index 1cf343e1..00000000
--- a/src/application/Context/State/Filter/Event/IFilterChangeDetails.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
-import { FilterActionType } from './FilterActionType';
-
-export interface IFilterChangeDetails {
-  readonly action: FilterAction;
-  visit(visitor: IFilterChangeDetailsVisitor): void;
-}
-
-export interface IFilterChangeDetailsVisitor {
-  readonly onClear?: () => void;
-  readonly onApply?: (filter: IFilterResult) => void;
-}
-
-export type ApplyFilterAction = {
-  readonly type: FilterActionType.Apply,
-  readonly filter: IFilterResult;
-};
-
-export type ClearFilterAction = {
-  readonly type: FilterActionType.Clear,
-};
-
-export type FilterAction = ApplyFilterAction | ClearFilterAction;
diff --git a/src/application/Context/State/Filter/FilterContext.ts b/src/application/Context/State/Filter/FilterContext.ts
new file mode 100644
index 00000000..2c5f592f
--- /dev/null
+++ b/src/application/Context/State/Filter/FilterContext.ts
@@ -0,0 +1,13 @@
+import { IEventSource } from '@/infrastructure/Events/IEventSource';
+import { FilterResult } from './Result/FilterResult';
+import { FilterChangeDetails } from './Event/FilterChangeDetails';
+
+export interface ReadonlyFilterContext {
+  readonly currentFilter: FilterResult | undefined;
+  readonly filterChanged: IEventSource<FilterChangeDetails>;
+}
+
+export interface FilterContext extends ReadonlyFilterContext {
+  applyFilter(filter: string): void;
+  clearFilter(): void;
+}
diff --git a/src/application/Context/State/Filter/IUserFilter.ts b/src/application/Context/State/Filter/IUserFilter.ts
deleted file mode 100644
index 60403187..00000000
--- a/src/application/Context/State/Filter/IUserFilter.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { IEventSource } from '@/infrastructure/Events/IEventSource';
-import { IFilterResult } from './IFilterResult';
-import { IFilterChangeDetails } from './Event/IFilterChangeDetails';
-
-export interface IReadOnlyUserFilter {
-  readonly currentFilter: IFilterResult | undefined;
-  readonly filterChanged: IEventSource<IFilterChangeDetails>;
-}
-
-export interface IUserFilter extends IReadOnlyUserFilter {
-  applyFilter(filter: string): void;
-  clearFilter(): void;
-}
diff --git a/src/application/Context/State/Filter/FilterResult.ts b/src/application/Context/State/Filter/Result/AppliedFilterResult.ts
similarity index 81%
rename from src/application/Context/State/Filter/FilterResult.ts
rename to src/application/Context/State/Filter/Result/AppliedFilterResult.ts
index 5c949ebe..a3aa2cb2 100644
--- a/src/application/Context/State/Filter/FilterResult.ts
+++ b/src/application/Context/State/Filter/Result/AppliedFilterResult.ts
@@ -1,8 +1,8 @@
 import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
-import { IFilterResult } from './IFilterResult';
+import { FilterResult } from './FilterResult';
 
-export class FilterResult implements IFilterResult {
+export class AppliedFilterResult implements FilterResult {
   constructor(
     public readonly scriptMatches: ReadonlyArray<IScript>,
     public readonly categoryMatches: ReadonlyArray<ICategory>,
diff --git a/src/application/Context/State/Filter/IFilterResult.ts b/src/application/Context/State/Filter/Result/FilterResult.ts
similarity index 86%
rename from src/application/Context/State/Filter/IFilterResult.ts
rename to src/application/Context/State/Filter/Result/FilterResult.ts
index 8391dc82..d9613df1 100644
--- a/src/application/Context/State/Filter/IFilterResult.ts
+++ b/src/application/Context/State/Filter/Result/FilterResult.ts
@@ -1,6 +1,6 @@
 import { IScript, ICategory } from '@/domain/ICategory';
 
-export interface IFilterResult {
+export interface FilterResult {
   readonly categoryMatches: ReadonlyArray<ICategory>;
   readonly scriptMatches: ReadonlyArray<IScript>;
   readonly query: string;
diff --git a/src/application/Context/State/Filter/Strategy/FilterStrategy.ts b/src/application/Context/State/Filter/Strategy/FilterStrategy.ts
new file mode 100644
index 00000000..2bda8de2
--- /dev/null
+++ b/src/application/Context/State/Filter/Strategy/FilterStrategy.ts
@@ -0,0 +1,9 @@
+import type { ICategoryCollection } from '@/domain/ICategoryCollection';
+import type { FilterResult } from '../Result/FilterResult';
+
+export interface FilterStrategy {
+  applyFilter(
+    filter: string,
+    collection: ICategoryCollection,
+  ): FilterResult;
+}
diff --git a/src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts b/src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts
new file mode 100644
index 00000000..c9c978ee
--- /dev/null
+++ b/src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts
@@ -0,0 +1,80 @@
+import type { ICategory, IScript } from '@/domain/ICategory';
+import type { IScriptCode } from '@/domain/IScriptCode';
+import type { IDocumentable } from '@/domain/IDocumentable';
+import type { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { AppliedFilterResult } from '../Result/AppliedFilterResult';
+import type { FilterStrategy } from './FilterStrategy';
+import type { FilterResult } from '../Result/FilterResult';
+
+export class LinearFilterStrategy implements FilterStrategy {
+  applyFilter(filter: string, collection: ICategoryCollection): FilterResult {
+    const filterLowercase = filter.toLocaleLowerCase();
+    const filteredScripts = collection.getAllScripts().filter(
+      (script) => matchesScript(script, filterLowercase),
+    );
+    const filteredCategories = collection.getAllCategories().filter(
+      (category) => matchesCategory(category, filterLowercase),
+    );
+    return new AppliedFilterResult(
+      filteredScripts,
+      filteredCategories,
+      filter,
+    );
+  }
+}
+
+function matchesCategory(
+  category: ICategory,
+  filterLowercase: string,
+): boolean {
+  return matchesAny(
+    () => matchName(category.name, filterLowercase),
+    () => matchDocumentation(category, filterLowercase),
+  );
+}
+
+function matchesScript(
+  script: IScript,
+  filterLowercase: string,
+): boolean {
+  return matchesAny(
+    () => matchName(script.name, filterLowercase),
+    () => matchCode(script.code, filterLowercase),
+    () => matchDocumentation(script, filterLowercase),
+  );
+}
+
+function matchesAny(
+  ...predicates: ReadonlyArray<() => boolean>
+): boolean {
+  return predicates.some((predicate) => predicate());
+}
+
+function matchName(
+  name: string,
+  filterLowercase: string,
+): boolean {
+  return name.toLowerCase().includes(filterLowercase);
+}
+
+function matchCode(
+  code: IScriptCode,
+  filterLowercase: string,
+): boolean {
+  if (code.execute.toLowerCase().includes(filterLowercase)) {
+    return true;
+  }
+  if (code.revert?.toLowerCase().includes(filterLowercase)) {
+    return true;
+  }
+  return false;
+}
+
+function matchDocumentation(
+  documentable: IDocumentable,
+  filterLowercase: string,
+): boolean {
+  return documentable.docs.some(
+    (doc) => doc.toLocaleLowerCase().includes(filterLowercase),
+  );
+}
diff --git a/src/application/Context/State/Filter/UserFilter.ts b/src/application/Context/State/Filter/UserFilter.ts
deleted file mode 100644
index 5e1e026d..00000000
--- a/src/application/Context/State/Filter/UserFilter.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import { IScript } from '@/domain/IScript';
-import { EventSource } from '@/infrastructure/Events/EventSource';
-import { ICategoryCollection } from '@/domain/ICategoryCollection';
-import { FilterResult } from './FilterResult';
-import { IFilterResult } from './IFilterResult';
-import { IUserFilter } from './IUserFilter';
-import { IFilterChangeDetails } from './Event/IFilterChangeDetails';
-import { FilterChange } from './Event/FilterChange';
-
-export class UserFilter implements IUserFilter {
-  public readonly filterChanged = new EventSource<IFilterChangeDetails>();
-
-  public currentFilter: IFilterResult | undefined;
-
-  constructor(private collection: ICategoryCollection) {
-
-  }
-
-  public applyFilter(filter: string): void {
-    if (!filter) {
-      throw new Error('Filter must be defined and not empty. Use clearFilter() to remove the filter');
-    }
-    const filterLowercase = filter.toLocaleLowerCase();
-    const filteredScripts = this.collection.getAllScripts().filter(
-      (script) => isScriptAMatch(script, filterLowercase),
-    );
-    const filteredCategories = this.collection.getAllCategories().filter(
-      (category) => category.name.toLowerCase().includes(filterLowercase),
-    );
-    const matches = new FilterResult(
-      filteredScripts,
-      filteredCategories,
-      filter,
-    );
-    this.currentFilter = matches;
-    this.filterChanged.notify(FilterChange.forApply(this.currentFilter));
-  }
-
-  public clearFilter(): void {
-    this.currentFilter = undefined;
-    this.filterChanged.notify(FilterChange.forClear());
-  }
-}
-
-function isScriptAMatch(script: IScript, filterLowercase: string) {
-  if (script.name.toLowerCase().includes(filterLowercase)) {
-    return true;
-  }
-  if (script.code.execute.toLowerCase().includes(filterLowercase)) {
-    return true;
-  }
-  if (script.code.revert) {
-    return script.code.revert.toLowerCase().includes(filterLowercase);
-  }
-  return false;
-}
diff --git a/src/application/Context/State/ICategoryCollectionState.ts b/src/application/Context/State/ICategoryCollectionState.ts
index 815aa413..3ae0e197 100644
--- a/src/application/Context/State/ICategoryCollectionState.ts
+++ b/src/application/Context/State/ICategoryCollectionState.ts
@@ -1,18 +1,18 @@
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { OperatingSystem } from '@/domain/OperatingSystem';
-import { IReadOnlyUserFilter, IUserFilter } from './Filter/IUserFilter';
+import { ReadonlyFilterContext, FilterContext } from './Filter/FilterContext';
 import { ReadonlyUserSelection, UserSelection } from './Selection/UserSelection';
 import { IApplicationCode } from './Code/IApplicationCode';
 
 export interface IReadOnlyCategoryCollectionState {
   readonly code: IApplicationCode;
   readonly os: OperatingSystem;
-  readonly filter: IReadOnlyUserFilter;
+  readonly filter: ReadonlyFilterContext;
   readonly selection: ReadonlyUserSelection;
   readonly collection: ICategoryCollection;
 }
 
 export interface ICategoryCollectionState extends IReadOnlyCategoryCollectionState {
-  readonly filter: IUserFilter;
+  readonly filter: FilterContext;
   readonly selection: UserSelection;
 }
diff --git a/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue b/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue
index f44c5062..8f3c24c1 100644
--- a/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue
+++ b/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue
@@ -16,7 +16,7 @@
 <script lang="ts">
 import { defineComponent, ref } from 'vue';
 import { injectKey } from '@/presentation/injectionSymbols';
-import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
+import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
 import { IEventSubscription } from '@/infrastructure/Events/IEventSource';
 import TheOsChanger from './TheOsChanger.vue';
 import TheViewChanger from './View/TheViewChanger.vue';
@@ -49,7 +49,7 @@ export default defineComponent({
     }, { immediate: true });
 
     function subscribeToFilterChanges(
-      filter: IReadOnlyUserFilter,
+      filter: ReadonlyFilterContext,
     ): IEventSubscription {
       return filter.filterChanged.on((event) => {
         event.visit({
diff --git a/src/presentation/components/Scripts/View/TheScriptsView.vue b/src/presentation/components/Scripts/View/TheScriptsView.vue
index 5b2c5b02..de43ceb7 100644
--- a/src/presentation/components/Scripts/View/TheScriptsView.vue
+++ b/src/presentation/components/Scripts/View/TheScriptsView.vue
@@ -43,8 +43,8 @@ import { injectKey } from '@/presentation/injectionSymbols';
 import ScriptsTree from '@/presentation/components/Scripts/View/Tree/ScriptsTree.vue';
 import CardList from '@/presentation/components/Scripts/View/Cards/CardList.vue';
 import { ViewType } from '@/presentation/components/Scripts/Menu/View/ViewType';
-import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import FlatButton from '@/presentation/components/Shared/FlatButton.vue';
 
 export default defineComponent({
@@ -94,12 +94,12 @@ export default defineComponent({
       });
     }
 
-    function updateFromInitialFilter(filter?: IFilterResult) {
+    function updateFromInitialFilter(filter?: FilterResult) {
       searchQuery.value = filter?.query;
       searchHasMatches.value = filter?.hasAnyMatches() ?? false;
     }
 
-    function subscribeToFilterChanges(filter: IReadOnlyUserFilter) {
+    function subscribeToFilterChanges(filter: ReadonlyFilterContext) {
       return filter.filterChanged.on((event) => {
         event.visit({
           onApply: (newFilter) => {
diff --git a/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts b/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts
index ee031914..8f5327c7 100644
--- a/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts
+++ b/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts
@@ -4,8 +4,8 @@ import {
 import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
 import { injectKey } from '@/presentation/injectionSymbols';
-import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { TreeViewFilterEvent, createFilterRemovedEvent, createFilterTriggeredEvent } from '../TreeView/Bindings/TreeInputFilterEvent';
 import { NodeMetadata } from '../NodeContent/NodeMetadata';
 import { ReadOnlyTreeNode } from '../TreeView/Node/TreeNode';
@@ -14,7 +14,7 @@ import { getCategoryNodeId, getScriptNodeId } from './CategoryNodeMetadataConver
 
 type TreeNodeFilterResultPredicate = (
   node: ReadOnlyTreeNode,
-  filterResult: IFilterResult,
+  filterResult: FilterResult,
 ) => boolean;
 
 export function useTreeViewFilterEvent() {
@@ -41,7 +41,7 @@ export function useTreeViewFilterEvent() {
 }
 
 function subscribeToFilterChanges(
-  filter: IReadOnlyUserFilter,
+  filter: ReadonlyFilterContext,
   latestFilterEvent: Ref<TreeViewFilterEvent | undefined>,
   filterPredicate: TreeNodeFilterResultPredicate,
 ) {
@@ -60,7 +60,7 @@ function subscribeToFilterChanges(
 }
 
 function createFilterEvent(
-  filter: IFilterResult | undefined,
+  filter: FilterResult | undefined,
   filterPredicate: TreeNodeFilterResultPredicate,
 ): TreeViewFilterEvent {
   if (!filter) {
@@ -71,7 +71,7 @@ function createFilterEvent(
   );
 }
 
-function filterMatches(node: NodeMetadata, filter: IFilterResult): boolean {
+function filterMatches(node: NodeMetadata, filter: FilterResult): boolean {
   return containsScript(node, filter.scriptMatches)
     || containsCategory(node, filter.categoryMatches);
 }
diff --git a/src/presentation/components/TheSearchBar.vue b/src/presentation/components/TheSearchBar.vue
index 422c1e84..9e84d7b5 100644
--- a/src/presentation/components/TheSearchBar.vue
+++ b/src/presentation/components/TheSearchBar.vue
@@ -19,8 +19,8 @@ import {
 import { injectKey } from '@/presentation/injectionSymbols';
 import { NonCollapsing } from '@/presentation/components/Scripts/View/Cards/NonCollapsingDirective';
 import AppIcon from '@/presentation/components/Shared/Icon/AppIcon.vue';
-import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { IEventSubscription } from '@/infrastructure/Events/IEventSource';
 
 export default defineComponent({
@@ -61,12 +61,12 @@ export default defineComponent({
       ]);
     }, { immediate: true });
 
-    function updateFromInitialFilter(filter?: IFilterResult) {
+    function updateFromInitialFilter(filter?: FilterResult) {
       searchQuery.value = filter?.query;
     }
 
     function subscribeToFilterChanges(
-      filter: IReadOnlyUserFilter,
+      filter: ReadonlyFilterContext,
     ): IEventSubscription {
       return filter.filterChanged.on((event) => {
         event.visit({
diff --git a/tests/unit/application/Context/State/CategoryCollectionState.spec.ts b/tests/unit/application/Context/State/CategoryCollectionState.spec.ts
index 45b05424..5f7f9ce5 100644
--- a/tests/unit/application/Context/State/CategoryCollectionState.spec.ts
+++ b/tests/unit/application/Context/State/CategoryCollectionState.spec.ts
@@ -11,8 +11,8 @@ import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 import { ReadonlyScriptSelection } from '@/application/Context/State/Selection/Script/ScriptSelection';
 import { ScriptSelectionStub } from '@tests/unit/shared/Stubs/ScriptSelectionStub';
 import { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
-import { UserFilterStub } from '@tests/unit/shared/Stubs/UserFilterStub';
 import type { CodeFactory, FilterFactory, SelectionFactory } from '@/application/Context/State/CategoryCollectionState';
+import { FilterContextStub } from '@tests/unit/shared/Stubs/FilterContextStub';
 
 describe('CategoryCollectionState', () => {
   describe('code', () => {
@@ -113,7 +113,7 @@ describe('CategoryCollectionState', () => {
       let actualCollection: ICategoryCollection | undefined;
       const filterFactoryMock: FilterFactory = (collection) => {
         actualCollection = collection;
-        return new UserFilterStub();
+        return new FilterContextStub();
       };
       // act
       new CategoryCollectionStateBuilder()
@@ -134,7 +134,7 @@ class CategoryCollectionStateBuilder {
 
   private selectionFactory: SelectionFactory = () => new UserSelectionStub();
 
-  private filterFactory: FilterFactory = () => new UserFilterStub();
+  private filterFactory: FilterFactory = () => new FilterContextStub();
 
   public withCollection(collection: ICategoryCollection): this {
     this.collection = collection;
diff --git a/tests/unit/application/Context/State/Filter/AdaptiveFilterContext.spec.ts b/tests/unit/application/Context/State/Filter/AdaptiveFilterContext.spec.ts
new file mode 100644
index 00000000..37cf6795
--- /dev/null
+++ b/tests/unit/application/Context/State/Filter/AdaptiveFilterContext.spec.ts
@@ -0,0 +1,130 @@
+import { describe, it, expect } from 'vitest';
+import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
+import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
+import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
+import { expectExists } from '@tests/shared/Assertions/ExpectExists';
+import { AdaptiveFilterContext } from '@/application/Context/State/Filter/AdaptiveFilterContext';
+import { FilterResultStub } from '@tests/unit/shared/Stubs/FilterResultStub';
+import { FilterStrategyStub } from '@tests/unit/shared/Stubs/FilterStrategyStub';
+import type { FilterStrategy } from '@/application/Context/State/Filter/Strategy/FilterStrategy';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+
+describe('AdaptiveFilterContext', () => {
+  describe('clearFilter', () => {
+    it('emits clear event on filter removal', () => {
+      // arrange
+      const expectedChange = FilterChangeDetailsStub.forClear();
+      let actualChange: FilterChangeDetails | undefined;
+      const context = new ContextBuilder().build();
+      context.filterChanged.on((change) => {
+        actualChange = change;
+      });
+      // act
+      context.clearFilter();
+      // assert
+      expectExists(actualChange);
+      expect(actualChange).to.deep.equal(expectedChange);
+    });
+    it('clears current filter', () => {
+      // arrange
+      const context = new ContextBuilder().build();
+      // act
+      context.applyFilter('non-important');
+      context.clearFilter();
+      // assert
+      expect(context.currentFilter).to.be.equal(undefined);
+    });
+  });
+  describe('applyFilter', () => {
+    it('updates current filter correctly', () => {
+      // arrange
+      const expectedFilter = new FilterResultStub();
+      const strategy = new FilterStrategyStub()
+        .withApplyFilterResult(expectedFilter);
+      const context = new ContextBuilder()
+        .withStrategy(strategy)
+        .build();
+      // act
+      context.applyFilter('non-important');
+      // assert
+      const actualFilter = context.currentFilter;
+      expect(actualFilter).to.equal(expectedFilter);
+    });
+    it('emits apply event with correct filter', () => {
+      // arrange
+      const expectedFilter = new FilterResultStub();
+      const strategy = new FilterStrategyStub()
+        .withApplyFilterResult(expectedFilter);
+      const context = new ContextBuilder()
+        .withStrategy(strategy)
+        .build();
+      let actualFilter: FilterResult | undefined;
+      context.filterChanged.on((filterResult) => {
+        filterResult.visit({
+          onApply: (result) => {
+            actualFilter = result;
+          },
+        });
+      });
+      // act
+      context.applyFilter('non-important');
+      // assert
+      expect(actualFilter).to.equal(expectedFilter);
+    });
+    it('applies filter using current collection', () => {
+      // arrange
+      const expectedCollection = new CategoryCollectionStub();
+      const strategy = new FilterStrategyStub();
+      const context = new ContextBuilder()
+        .withStrategy(strategy)
+        .withCategoryCollection(expectedCollection)
+        .build();
+      // act
+      context.applyFilter('non-important');
+      // assert
+      const applyFilterCalls = strategy.callHistory.filter((c) => c.methodName === 'applyFilter');
+      expect(applyFilterCalls).to.have.lengthOf(1);
+      const [, actualCollection] = applyFilterCalls[0].args;
+      expect(actualCollection).to.equal(expectedCollection);
+    });
+    it('applies filter with given query', () => {
+      // arrange
+      const expectedQuery = 'expected-query';
+      const strategy = new FilterStrategyStub();
+      const context = new ContextBuilder()
+        .withStrategy(strategy)
+        .build();
+      // act
+      context.applyFilter(expectedQuery);
+      // assert
+      const applyFilterCalls = strategy.callHistory.filter((c) => c.methodName === 'applyFilter');
+      expect(applyFilterCalls).to.have.lengthOf(1);
+      const [actualQuery] = applyFilterCalls[0].args;
+      expect(actualQuery).to.equal(expectedQuery);
+    });
+  });
+});
+
+class ContextBuilder {
+  private categoryCollection: ICategoryCollection = new CategoryCollectionStub();
+
+  private filterStrategy: FilterStrategy = new FilterStrategyStub();
+
+  public build(): AdaptiveFilterContext {
+    return new AdaptiveFilterContext(
+      this.categoryCollection,
+      this.filterStrategy,
+    );
+  }
+
+  public withStrategy(strategy: FilterStrategy): this {
+    this.filterStrategy = strategy;
+    return this;
+  }
+
+  public withCategoryCollection(categoryCollection: ICategoryCollection): this {
+    this.categoryCollection = categoryCollection;
+    return this;
+  }
+}
diff --git a/tests/unit/application/Context/State/Filter/Event/FilterChange.spec.ts b/tests/unit/application/Context/State/Filter/Event/FilterChange.spec.ts
index 6ed05667..02031d34 100644
--- a/tests/unit/application/Context/State/Filter/Event/FilterChange.spec.ts
+++ b/tests/unit/application/Context/State/Filter/Event/FilterChange.spec.ts
@@ -3,7 +3,8 @@ import { FilterChange } from '@/application/Context/State/Filter/Event/FilterCha
 import { FilterResultStub } from '@tests/unit/shared/Stubs/FilterResultStub';
 import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
 import { FilterChangeDetailsVisitorStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub';
-import { ApplyFilterAction } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
+import { ApplyFilterAction } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
+import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 
 describe('FilterChange', () => {
   describe('forApply', () => {
@@ -48,14 +49,48 @@ describe('FilterChange', () => {
   });
   describe('visit', () => {
     describe('onClear', () => {
-      itVisitsOnce(
-        () => FilterChange.forClear(),
-      );
+      it('visits once', () => {
+        // arrange
+        const sut = FilterChange.forClear();
+        const visitor = new FilterChangeDetailsVisitorStub();
+        // act
+        sut.visit(visitor);
+        // assert
+        expect(visitor.callHistory).to.have.lengthOf(1);
+      });
+
+      it('visits onClear', () => {
+        // arrange
+        const sut = FilterChange.forClear();
+        const visitor = new FilterChangeDetailsVisitorStub();
+        // act
+        sut.visit(visitor);
+        // assert
+        const call = visitor.callHistory.find((c) => c.methodName === 'onClear');
+        expect(call).toBeDefined();
+      });
     });
     describe('onApply', () => {
-      itVisitsOnce(
-        () => FilterChange.forApply(new FilterResultStub()),
-      );
+      it('visits once', () => {
+        // arrange
+        const sut = FilterChange.forApply(new FilterResultStub());
+        const visitor = new FilterChangeDetailsVisitorStub();
+        // act
+        sut.visit(visitor);
+        // assert
+        expect(visitor.callHistory).to.have.lengthOf(1);
+      });
+
+      it('visits onApply', () => {
+        // arrange
+        const sut = FilterChange.forApply(new FilterResultStub());
+        const visitor = new FilterChangeDetailsVisitorStub();
+        // act
+        sut.visit(visitor);
+        // assert
+        const call = visitor.callHistory.find((c) => c.methodName === 'onApply');
+        expect(call).toBeDefined();
+      });
 
       it('visits with expected filter', () => {
         // arrange
@@ -65,34 +100,11 @@ describe('FilterChange', () => {
         // act
         sut.visit(visitor);
         // assert
-        expect(visitor.visitedResults).to.have.lengthOf(1);
-        expect(visitor.visitedResults).to.include(expectedFilter);
+        const call = visitor.callHistory.find((c) => c.methodName === 'onApply');
+        expectExists(call);
+        const [actualFilter] = call.args;
+        expect(actualFilter).to.equal(expectedFilter);
       });
     });
   });
 });
-
-function itVisitsOnce(sutFactory: () => FilterChange) {
-  it('visits', () => {
-    // arrange
-    const sut = sutFactory();
-    const expectedType = sut.action.type;
-    const visitor = new FilterChangeDetailsVisitorStub();
-    // act
-    sut.visit(visitor);
-    // assert
-    expect(visitor.visitedEvents).to.include(expectedType);
-  });
-  it('visits once', () => {
-    // arrange
-    const sut = sutFactory();
-    const expectedType = sut.action.type;
-    const visitor = new FilterChangeDetailsVisitorStub();
-    // act
-    sut.visit(visitor);
-    // assert
-    expect(
-      visitor.visitedEvents.filter((action) => action === expectedType),
-    ).to.have.lengthOf(1);
-  });
-}
diff --git a/tests/unit/application/Context/State/Filter/FilterResult.spec.ts b/tests/unit/application/Context/State/Filter/FilterResult.spec.ts
deleted file mode 100644
index b39492e0..00000000
--- a/tests/unit/application/Context/State/Filter/FilterResult.spec.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { FilterResult } from '@/application/Context/State/Filter/FilterResult';
-import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
-import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
-
-describe('FilterResult', () => {
-  describe('hasAnyMatches', () => {
-    it('false when no matches', () => {
-      const sut = new FilterResult(
-        /* scriptMatches */ [],
-        /* categoryMatches */ [],
-        'query',
-      );
-      const actual = sut.hasAnyMatches();
-      expect(actual).to.equal(false);
-    });
-    it('true when script matches', () => {
-      const sut = new FilterResult(
-        /* scriptMatches */ [new ScriptStub('id')],
-        /* categoryMatches */ [],
-        'query',
-      );
-      const actual = sut.hasAnyMatches();
-      expect(actual).to.equal(true);
-    });
-    it('true when category matches', () => {
-      const sut = new FilterResult(
-        /* scriptMatches */ [],
-        /* categoryMatches */ [new CategoryStub(5)],
-        'query',
-      );
-      const actual = sut.hasAnyMatches();
-      expect(actual).to.equal(true);
-    });
-    it('true when script + category matches', () => {
-      const sut = new FilterResult(
-        /* scriptMatches */ [new ScriptStub('id')],
-        /* categoryMatches */ [new CategoryStub(5)],
-        'query',
-      );
-      const actual = sut.hasAnyMatches();
-      expect(actual).to.equal(true);
-    });
-  });
-});
diff --git a/tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts b/tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts
new file mode 100644
index 00000000..f20c42aa
--- /dev/null
+++ b/tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts
@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
+import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
+import { AppliedFilterResult } from '@/application/Context/State/Filter/Result/AppliedFilterResult';
+import { ICategory, IScript } from '@/domain/ICategory';
+
+describe('AppliedFilterResult', () => {
+  describe('constructor', () => {
+    it('initializes query correctly', () => {
+      // arrange
+      const expectedQuery = 'expected query';
+      const builder = new ResultBuilder()
+        .withQuery(expectedQuery);
+      // act
+      const result = builder.build();
+      // assert
+      const actualQuery = result.query;
+      expect(actualQuery).to.equal(expectedQuery);
+    });
+  });
+  describe('hasAnyMatches', () => {
+    it('returns false with no matches', () => {
+      // arrange
+      const expected = false;
+      const result = new ResultBuilder()
+        .withScriptMatches([])
+        .withCategoryMatches([])
+        .build();
+      // act
+      const actual = result.hasAnyMatches();
+      // assert
+      expect(actual).to.equal(expected);
+    });
+    it('returns true with script matches', () => {
+      // arrange
+      const expected = true;
+      const result = new ResultBuilder()
+        .withScriptMatches([new ScriptStub('id')])
+        .withCategoryMatches([])
+        .build();
+      // act
+      const actual = result.hasAnyMatches();
+      expect(actual).to.equal(expected);
+    });
+    it('returns true with category matches', () => {
+      // arrange
+      const expected = true;
+      const result = new ResultBuilder()
+        .withScriptMatches([])
+        .withCategoryMatches([new CategoryStub(5)])
+        .build();
+      // act
+      const actual = result.hasAnyMatches();
+      expect(actual).to.equal(expected);
+    });
+    it('returns true with script and category matches', () => {
+      // arrange
+      const expected = true;
+      const result = new ResultBuilder()
+        .withScriptMatches([new ScriptStub('id')])
+        .withCategoryMatches([new CategoryStub(5)])
+        .build();
+      // act
+      const actual = result.hasAnyMatches();
+      expect(actual).to.equal(expected);
+    });
+  });
+});
+
+class ResultBuilder {
+  private scriptMatches: readonly IScript[] = [new ScriptStub('id')];
+
+  private categoryMatches: readonly ICategory[] = [new CategoryStub(5)];
+
+  private query: string = `[${ResultBuilder.name}]query`;
+
+  public withScriptMatches(scriptMatches: readonly IScript[]): this {
+    this.scriptMatches = scriptMatches;
+    return this;
+  }
+
+  public withCategoryMatches(categoryMatches: readonly ICategory[]): this {
+    this.categoryMatches = categoryMatches;
+    return this;
+  }
+
+  public withQuery(query: string) {
+    this.query = query;
+    return this;
+  }
+
+  public build(): AppliedFilterResult {
+    return new AppliedFilterResult(
+      this.scriptMatches,
+      this.categoryMatches,
+      this.query,
+    );
+  }
+}
diff --git a/tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts b/tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts
new file mode 100644
index 00000000..87e20896
--- /dev/null
+++ b/tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts
@@ -0,0 +1,278 @@
+import { describe, it, expect } from 'vitest';
+import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
+import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
+import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { ICategory } from '@/domain/ICategory';
+import { IScript } from '@/domain/IScript';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import { LinearFilterStrategy } from '@/application/Context/State/Filter/Strategy/LinearFilterStrategy';
+
+describe('LinearFilterStrategy', () => {
+  describe('applyFilter', () => {
+    describe('query', () => {
+      it('returns provided filter', () => {
+        // arrange
+        const expectedQuery = 'non matching filter';
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(expectedQuery);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.query).to.equal(expectedQuery);
+      });
+    });
+    describe('hasAnyMatches', () => {
+      it('returns false when there are no matches', () => {
+        // arrange
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter('non matching filter')
+          .withCollection(new CategoryCollectionStub());
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.hasAnyMatches()).be.equal(false);
+      });
+      it('returns true for a script match', () => {
+        // arrange
+        const matchingFilter = 'matching filter';
+        const collection = new CategoryCollectionStub()
+          .withAction(new CategoryStub(2).withScript(createMatchingScript(matchingFilter)));
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(matchingFilter)
+          .withCollection(collection);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.hasAnyMatches()).be.equal(true);
+      });
+      it('returns true for a category match', () => {
+        // arrange
+        const matchingFilter = 'matching filter';
+        const collection = new CategoryCollectionStub()
+          .withAction(createMatchingCategory(matchingFilter));
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(matchingFilter)
+          .withCollection(collection);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.hasAnyMatches()).be.equal(true);
+      });
+      it('returns true for script and category matches', () => {
+        // arrange
+        const matchingFilter = 'matching filter';
+        const collection = new CategoryCollectionStub()
+          .withAction(createMatchingCategory(matchingFilter))
+          .withAction(new CategoryStub(2).withScript(createMatchingScript(matchingFilter)));
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(matchingFilter)
+          .withCollection(collection);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.hasAnyMatches()).be.equal(true);
+      });
+    });
+    describe('scriptMatches', () => {
+      it('returns empty when there are no matches', () => {
+        // arrange
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter('non matching filter')
+          .withCollection(new CategoryCollectionStub());
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.scriptMatches).to.have.lengthOf(0);
+      });
+      describe('returns single matching script', () => {
+        interface ScriptMatchTestScenario {
+          readonly description: string;
+          readonly filter: string;
+          readonly matchingScript: IScript;
+        }
+        const testScenarios: readonly ScriptMatchTestScenario[] = [
+          {
+            description: 'case-insensitive code',
+            filter: 'Hello WoRLD',
+            matchingScript: new ScriptStub('id').withCode('HELLO world'),
+          },
+          {
+            description: 'case-insensitive revert code',
+            filter: 'Hello WoRLD',
+            matchingScript: new ScriptStub('id').withRevertCode('HELLO world'),
+          },
+          {
+            description: 'case-insensitive name',
+            filter: 'Hello WoRLD',
+            matchingScript: new ScriptStub('id').withName('HELLO world'),
+          },
+          {
+            description: 'case-insensitive documentation',
+            filter: 'MaTChing doC',
+            matchingScript: new ScriptStub('id').withDocs(['unrelated docs', 'matching Docs']),
+          },
+        ];
+        testScenarios.forEach(({
+          description, filter, matchingScript,
+        }) => {
+          it(description, () => {
+            // arrange
+            const expectedMatches = [matchingScript];
+            const collection = new CategoryCollectionStub()
+              .withAction(new CategoryStub(33).withScript(matchingScript));
+            const strategy = new FilterStrategyTestBuilder()
+              .withFilter(filter)
+              .withCollection(collection);
+            // act
+            const result = strategy.applyFilter();
+            // assert
+            expectScriptMatches(result, expectedMatches);
+          });
+        });
+      });
+      it('returns multiple matching scripts', () => {
+        // arrange
+        const filter = 'matching filter';
+        const matchingScripts: readonly IScript[] = [
+          createMatchingScript(filter),
+          createMatchingScript(filter),
+        ];
+        const expectedMatches = [...matchingScripts];
+        const collection = new CategoryCollectionStub()
+          .withAction(new CategoryStub(0).withScripts(...matchingScripts));
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(filter)
+          .withCollection(collection);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expectScriptMatches(result, expectedMatches);
+      });
+    });
+    describe('categoryMatches', () => {
+      it('returns empty when there are no matches', () => {
+        // arrange
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter('non matching filter')
+          .withCollection(new CategoryCollectionStub());
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.categoryMatches).to.have.lengthOf(0);
+      });
+      describe('returns single matching category', () => {
+        interface CategoryMatchTestScenario {
+          readonly description: string;
+          readonly filter: string;
+          readonly matchingCategory: ICategory;
+        }
+        const testScenarios: readonly CategoryMatchTestScenario[] = [
+          {
+            description: 'match with case-insensitive name',
+            filter: 'Hello WoRLD',
+            matchingCategory: new CategoryStub(55).withName('HELLO world'),
+          },
+          {
+            description: 'case-sensitive documentation',
+            filter: 'Hello WoRLD',
+            matchingCategory: new CategoryStub(55).withDocs(['unrelated-docs', 'HELLO world']),
+          },
+        ];
+        testScenarios.forEach(({
+          description, filter, matchingCategory,
+        }) => {
+          it(description, () => {
+            // arrange
+            const expectedMatches = [matchingCategory];
+            const collection = new CategoryCollectionStub()
+              .withAction(matchingCategory);
+            const strategy = new FilterStrategyTestBuilder()
+              .withFilter(filter)
+              .withCollection(collection);
+            // act
+            const result = strategy.applyFilter();
+            // assert
+            expectCategoryMatches(result, expectedMatches);
+          });
+        });
+      });
+      it('returns multiple matching categories', () => {
+        // arrange
+        const filter = 'matching filter';
+        const matchingCategories: readonly ICategory[] = [
+          createMatchingCategory(filter),
+          createMatchingCategory(filter),
+        ];
+        const expectedMatches = [...matchingCategories];
+        const collection = new CategoryCollectionStub()
+          .withActions(...matchingCategories);
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(filter)
+          .withCollection(collection);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expectCategoryMatches(result, expectedMatches);
+      });
+    });
+  });
+});
+
+function createMatchingScript(
+  matchingFilter: string,
+): ScriptStub {
+  return new ScriptStub('matching-script')
+    .withCode(matchingFilter)
+    .withName(matchingFilter);
+}
+
+function createMatchingCategory(
+  matchingFilter: string,
+): CategoryStub {
+  return new CategoryStub(1)
+    .withName(matchingFilter)
+    .withDocs([matchingFilter]);
+}
+
+function expectCategoryMatches(
+  actualFilter: FilterResult,
+  expectedMatches: readonly ICategory[],
+): void {
+  expect(actualFilter.hasAnyMatches()).be.equal(true);
+  expect(actualFilter.categoryMatches).to.have.lengthOf(expectedMatches.length);
+  expect(actualFilter.categoryMatches).to.have.members(expectedMatches);
+}
+
+function expectScriptMatches(
+  actualFilter: FilterResult,
+  expectedMatches: readonly IScript[],
+): void {
+  expect(actualFilter.hasAnyMatches()).be.equal(true);
+  expect(actualFilter.scriptMatches).to.have.lengthOf(expectedMatches.length);
+  expect(actualFilter.scriptMatches).to.have.members(expectedMatches);
+}
+
+class FilterStrategyTestBuilder {
+  private filter: string = `[${FilterStrategyTestBuilder.name}]filter`;
+
+  private collection: ICategoryCollection = new CategoryCollectionStub();
+
+  public withCollection(collection: ICategoryCollection): this {
+    this.collection = collection;
+    return this;
+  }
+
+  public withFilter(filter: string): this {
+    this.filter = filter;
+    return this;
+  }
+
+  public applyFilter(): ReturnType<LinearFilterStrategy['applyFilter']> {
+    const strategy = new LinearFilterStrategy();
+    return strategy.applyFilter(
+      this.filter,
+      this.collection,
+    );
+  }
+}
diff --git a/tests/unit/application/Context/State/Filter/UserFilter.spec.ts b/tests/unit/application/Context/State/Filter/UserFilter.spec.ts
deleted file mode 100644
index 356a45a3..00000000
--- a/tests/unit/application/Context/State/Filter/UserFilter.spec.ts
+++ /dev/null
@@ -1,194 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
-import { UserFilter } from '@/application/Context/State/Filter/UserFilter';
-import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
-import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
-import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
-import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
-import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
-import { ICategoryCollection } from '@/domain/ICategoryCollection';
-import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-
-describe('UserFilter', () => {
-  describe('clearFilter', () => {
-    it('signals when removing filter', () => {
-      // arrange
-      const expectedChange = FilterChangeDetailsStub.forClear();
-      let actualChange: IFilterChangeDetails | undefined;
-      const sut = new UserFilter(new CategoryCollectionStub());
-      sut.filterChanged.on((change) => {
-        actualChange = change;
-      });
-      // act
-      sut.clearFilter();
-      // assert
-      expectExists(actualChange);
-      expect(actualChange).to.deep.equal(expectedChange);
-    });
-    it('sets currentFilter to undefined', () => {
-      // arrange
-      const sut = new UserFilter(new CategoryCollectionStub());
-      // act
-      sut.applyFilter('non-important');
-      sut.clearFilter();
-      // assert
-      expect(sut.currentFilter).to.be.equal(undefined);
-    });
-  });
-  describe('applyFilter', () => {
-    interface IApplyFilterTestCase {
-      readonly name: string;
-      readonly filter: string;
-      readonly collection: ICategoryCollection;
-      readonly assert: (result: IFilterResult) => void;
-    }
-    const testCases: readonly IApplyFilterTestCase[] = [
-      (() => {
-        const nonMatchingFilter = 'non matching filter';
-        return {
-          name: 'given no matches',
-          filter: nonMatchingFilter,
-          collection: new CategoryCollectionStub(),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(false);
-            expect(filter.query).to.equal(nonMatchingFilter);
-          },
-        };
-      })(),
-      (() => {
-        const code = 'HELLO world';
-        const matchingFilter = 'Hello WoRLD';
-        const script = new ScriptStub('id').withCode(code);
-        return {
-          name: 'given script match with case-insensitive code',
-          filter: matchingFilter,
-          collection: new CategoryCollectionStub()
-            .withAction(new CategoryStub(33).withScript(script)),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(true);
-            expect(filter.categoryMatches).to.have.lengthOf(0);
-            expect(filter.scriptMatches).to.have.lengthOf(1);
-            expect(filter.scriptMatches[0]).to.deep.equal(script);
-            expect(filter.query).to.equal(matchingFilter);
-          },
-        };
-      })(),
-      (() => {
-        const revertCode = 'HELLO world';
-        const matchingFilter = 'Hello WoRLD';
-        const script = new ScriptStub('id').withRevertCode(revertCode);
-        return {
-          name: 'given script match with case-insensitive revertCode',
-          filter: matchingFilter,
-          collection: new CategoryCollectionStub()
-            .withAction(new CategoryStub(33).withScript(script)),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(true);
-            expect(filter.categoryMatches).to.have.lengthOf(0);
-            expect(filter.scriptMatches).to.have.lengthOf(1);
-            expect(filter.scriptMatches[0]).to.deep.equal(script);
-            expect(filter.query).to.equal(matchingFilter);
-          },
-        };
-      })(),
-      (() => {
-        const name = 'HELLO world';
-        const matchingFilter = 'Hello WoRLD';
-        const script = new ScriptStub('id').withName(name);
-        return {
-          name: 'given script match with case-insensitive name',
-          filter: matchingFilter,
-          collection: new CategoryCollectionStub()
-            .withAction(new CategoryStub(33).withScript(script)),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(true);
-            expect(filter.categoryMatches).to.have.lengthOf(0);
-            expect(filter.scriptMatches).to.have.lengthOf(1);
-            expect(filter.scriptMatches[0]).to.deep.equal(script);
-            expect(filter.query).to.equal(matchingFilter);
-          },
-        };
-      })(),
-      (() => {
-        const categoryName = 'HELLO world';
-        const matchingFilter = 'Hello WoRLD';
-        const category = new CategoryStub(55).withName(categoryName);
-        return {
-          name: 'given category match with case-insensitive name',
-          filter: matchingFilter,
-          collection: new CategoryCollectionStub()
-            .withAction(category),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(true);
-            expect(filter.categoryMatches).to.have.lengthOf(1);
-            expect(filter.categoryMatches[0]).to.deep.equal(category);
-            expect(filter.scriptMatches).to.have.lengthOf(0);
-            expect(filter.query).to.equal(matchingFilter);
-          },
-        };
-      })(),
-      (() => {
-        const matchingText = 'HELLO world';
-        const matchingFilter = 'Hello WoRLD';
-        const script = new ScriptStub('script')
-          .withName(matchingText);
-        const category = new CategoryStub(55)
-          .withName(matchingText)
-          .withScript(script);
-        return {
-          name: 'given category and script matches with case-insensitive names',
-          filter: matchingFilter,
-          collection: new CategoryCollectionStub()
-            .withAction(category),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(true);
-            expect(filter.categoryMatches).to.have.lengthOf(1);
-            expect(filter.categoryMatches[0]).to.deep.equal(category);
-            expect(filter.scriptMatches).to.have.lengthOf(1);
-            expect(filter.scriptMatches[0]).to.deep.equal(script);
-            expect(filter.query).to.equal(matchingFilter);
-          },
-        };
-      })(),
-    ];
-    describe('sets currentFilter as expected', () => {
-      testCases.forEach(({
-        name, filter, collection, assert,
-      }) => {
-        it(name, () => {
-          // arrange
-          const sut = new UserFilter(collection);
-          // act
-          sut.applyFilter(filter);
-          // assert
-          const actual = sut.currentFilter;
-          expectExists(actual);
-          assert(actual);
-        });
-      });
-    });
-    describe('signals as expected', () => {
-      testCases.forEach(({
-        name, filter, collection, assert,
-      }) => {
-        it(name, () => {
-          // arrange
-          const sut = new UserFilter(collection);
-          let actualFilterResult: IFilterResult | undefined;
-          sut.filterChanged.on((filterResult) => {
-            filterResult.visit({
-              onApply: (result) => {
-                actualFilterResult = result;
-              },
-            });
-          });
-          // act
-          sut.applyFilter(filter);
-          // assert
-          expectExists(actualFilterResult);
-          assert(actualFilterResult);
-        });
-      });
-    });
-  });
-});
diff --git a/tests/unit/presentation/components/Scripts/View/TheScriptsView.spec.ts b/tests/unit/presentation/components/Scripts/View/TheScriptsView.spec.ts
index 3a911449..5dc1af8d 100644
--- a/tests/unit/presentation/components/Scripts/View/TheScriptsView.spec.ts
+++ b/tests/unit/presentation/components/Scripts/View/TheScriptsView.spec.ts
@@ -9,12 +9,12 @@ import { useCollectionState } from '@/presentation/components/Shared/Hooks/UseCo
 import { UseCollectionStateStub } from '@tests/unit/shared/Stubs/UseCollectionStateStub';
 import { InjectionKeys } from '@/presentation/injectionSymbols';
 import { UseApplicationStub } from '@tests/unit/shared/Stubs/UseApplicationStub';
-import { UserFilterMethod, UserFilterStub } from '@tests/unit/shared/Stubs/UserFilterStub';
 import { FilterResultStub } from '@tests/unit/shared/Stubs/FilterResultStub';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
-import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
+import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
 import { UseAutoUnsubscribedEventsStub } from '@tests/unit/shared/Stubs/UseAutoUnsubscribedEventsStub';
 import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
+import { FilterContextStub } from '@tests/unit/shared/Stubs/FilterContextStub';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 
 const DOM_SELECTOR_NO_MATCHES = '.search-no-matches';
 const DOM_SELECTOR_CLOSE_BUTTON = '.search__query__close-button';
@@ -22,12 +22,12 @@ const DOM_SELECTOR_CLOSE_BUTTON = '.search__query__close-button';
 describe('TheScriptsView.vue', () => {
   describe('view types', () => {
     describe('initially', () => {
-      interface IInitialViewTypeTestCase {
+      interface InitialViewTypeTestCase {
         readonly initialView: ViewType;
         readonly expectedComponent: Component;
         readonly absentComponents: readonly Component[];
       }
-      const testCases: readonly IInitialViewTypeTestCase[] = [
+      const testCases: readonly InitialViewTypeTestCase[] = [
         {
           initialView: ViewType.Tree,
           expectedComponent: ScriptsTree,
@@ -96,20 +96,20 @@ describe('TheScriptsView.vue', () => {
   });
 
   describe('switching views', () => {
-    interface ISwitchingViewTestCase {
+    interface ViewSwitchTestScenario {
       readonly name: string;
       readonly initialView: ViewType;
-      readonly changeEvents: readonly IFilterChangeDetails[];
+      readonly changeEvents: readonly FilterChangeDetails[];
       readonly componentsToDisappear: readonly Component[];
       readonly expectedComponent: Component;
-      readonly setupFilter?: (filter: UserFilterStub) => UserFilterStub;
+      readonly setupFilter?: (filter: FilterContextStub) => FilterContextStub;
     }
-    const testCases: readonly ISwitchingViewTestCase[] = [
+    const testCases: readonly ViewSwitchTestScenario[] = [
       {
         name: 'tree on initial search with card view',
         initialView: ViewType.Cards,
-        setupFilter: (filter: UserFilterStub) => filter
-          .withCurrentFilterResult(
+        setupFilter: (filter: FilterContextStub) => filter
+          .withCurrentFilter(
             new FilterResultStub().withQueryAndSomeMatches(),
           ),
         changeEvents: [],
@@ -119,8 +119,8 @@ describe('TheScriptsView.vue', () => {
       {
         name: 'restore card after initial search',
         initialView: ViewType.Cards,
-        setupFilter: (filter: UserFilterStub) => filter
-          .withCurrentFilterResult(
+        setupFilter: (filter: FilterContextStub) => filter
+          .withCurrentFilter(
             new FilterResultStub().withQueryAndSomeMatches(),
           ),
         changeEvents: [
@@ -171,7 +171,7 @@ describe('TheScriptsView.vue', () => {
     }) => {
       it(name, async () => {
         // arrange
-        let filterStub = new UserFilterStub();
+        let filterStub = new FilterContextStub();
         if (setupFilter) {
           filterStub = setupFilter(filterStub);
         }
@@ -201,7 +201,7 @@ describe('TheScriptsView.vue', () => {
       describe('does not show close button when not searching', () => {
         it('not searching initially', () => {
           // arrange
-          const filterStub = new UserFilterStub()
+          const filterStub = new FilterContextStub()
             .withNoCurrentFilter();
           const stateStub = new UseCollectionStateStub()
             .withFilter(filterStub);
@@ -217,7 +217,7 @@ describe('TheScriptsView.vue', () => {
         });
         it('stop searching', async () => {
           // arrange
-          const filterStub = new UserFilterStub();
+          const filterStub = new FilterContextStub();
           const stateStub = new UseCollectionStateStub().withFilter(filterStub);
           const wrapper = mountComponent({
             useCollectionState: stateStub.get(),
@@ -239,8 +239,8 @@ describe('TheScriptsView.vue', () => {
       describe('shows close button when searching', () => {
         it('searching initially', () => {
           // arrange
-          const filterStub = new UserFilterStub()
-            .withCurrentFilterResult(
+          const filterStub = new FilterContextStub()
+            .withCurrentFilter(
               new FilterResultStub().withQueryAndSomeMatches(),
             );
           const stateStub = new UseCollectionStateStub()
@@ -257,7 +257,7 @@ describe('TheScriptsView.vue', () => {
         });
         it('start searching', async () => {
           // arrange
-          const filterStub = new UserFilterStub()
+          const filterStub = new FilterContextStub()
             .withNoCurrentFilter();
           const stateStub = new UseCollectionStateStub().withFilter(filterStub);
           const wrapper = mountComponent({
@@ -279,7 +279,7 @@ describe('TheScriptsView.vue', () => {
 
     it('clears search query on close button click', async () => {
       // arrange
-      const filterStub = new UserFilterStub();
+      const filterStub = new FilterContextStub();
       const stateStub = new UseCollectionStateStub().withFilter(filterStub);
       const wrapper = mountComponent({
         useCollectionState: stateStub.get(),
@@ -296,14 +296,14 @@ describe('TheScriptsView.vue', () => {
 
       // assert
       expect(filterStub.callHistory).to.have.lengthOf(1);
-      expect(filterStub.callHistory).to.include(UserFilterMethod.ClearFilter);
+      expect(filterStub.callHistory.find((c) => c.methodName === 'clearFilter')).toBeDefined();
     });
   });
 
   describe('no matches text', () => {
     interface NoMatchesTextTestCase {
       readonly name: string;
-      readonly filter: IFilterResult;
+      readonly filter: FilterResult;
       readonly shouldNoMatchesExist: boolean;
     }
     const commonTestCases: readonly NoMatchesTextTestCase[] = [
@@ -322,7 +322,7 @@ describe('TheScriptsView.vue', () => {
     ];
     describe('initial state', () => {
       interface InitialStateTestCase extends Omit<NoMatchesTextTestCase, 'filter'> {
-        readonly filter?: IFilterResult;
+        readonly filter?: FilterResult;
       }
       const initialStateTestCases: readonly InitialStateTestCase[] = [
         ...commonTestCases,
@@ -355,7 +355,7 @@ describe('TheScriptsView.vue', () => {
         it(name, async () => {
           // arrange
           const expected = shouldNoMatchesExist;
-          const filterStub = new UserFilterStub();
+          const filterStub = new FilterContextStub();
           const stateStub = new UseCollectionStateStub()
             .withFilter(filterStub);
           const wrapper = mountComponent({
@@ -375,7 +375,7 @@ describe('TheScriptsView.vue', () => {
       });
       it('shows no text if filter is removed after matches', async () => {
         // arrange
-        const filter = new UserFilterStub();
+        const filter = new FilterContextStub();
         const stub = new UseCollectionStateStub()
           .withFilter(filter);
         const wrapper = mountComponent({
diff --git a/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.spec.ts b/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.spec.ts
index 033d5c76..b120c6cb 100644
--- a/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.spec.ts
+++ b/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.spec.ts
@@ -14,14 +14,14 @@ import { HierarchyAccessStub } from '@tests/unit/shared/Stubs/HierarchyAccessStu
 import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
 import { TreeNode } from '@/presentation/components/Scripts/View/Tree/TreeView/Node/TreeNode';
-import { UserFilterStub } from '@tests/unit/shared/Stubs/UserFilterStub';
 import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
-import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
+import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
 import { CategoryCollectionStateStub } from '@tests/unit/shared/Stubs/CategoryCollectionStateStub';
 import { NodeMetadataStub } from '@tests/unit/shared/Stubs/NodeMetadataStub';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
+import { FilterContextStub } from '@tests/unit/shared/Stubs/FilterContextStub';
 
 describe('UseTreeViewFilterEvent', () => {
   describe('initially', () => {
@@ -45,8 +45,8 @@ describe('UseTreeViewFilterEvent', () => {
         // arrange
         const newFilter = filterChange;
         const initialFilter = new FilterResultStub().withSomeMatches();
-        const filterStub = new UserFilterStub()
-          .withCurrentFilterResult(initialFilter);
+        const filterStub = new FilterContextStub()
+          .withCurrentFilter(initialFilter);
         const stateStub = new UseCollectionStateStub()
           .withFilter(filterStub);
         const { returnObject } = mountWrapperComponent({ useStateStub: stateStub });
@@ -63,8 +63,8 @@ describe('UseTreeViewFilterEvent', () => {
         // arrange
         const newFilter = filterChange;
         const initialFilter = new FilterResultStub().withSomeMatches();
-        const filterStub = new UserFilterStub()
-          .withCurrentFilterResult(initialFilter);
+        const filterStub = new FilterContextStub()
+          .withCurrentFilter(initialFilter);
         const stateStub = new UseCollectionStateStub()
           .withFilter(filterStub);
         const { returnObject } = mountWrapperComponent({ useStateStub: stateStub });
@@ -90,7 +90,7 @@ describe('UseTreeViewFilterEvent', () => {
       testFilterEvents((_, filterResult) => {
         // arrange
         const newCollection = new CategoryCollectionStateStub()
-          .withFilter(new UserFilterStub().withCurrentFilterResult(filterResult));
+          .withFilter(new FilterContextStub().withCurrentFilter(filterResult));
         const initialCollection = new CategoryCollectionStateStub();
         const useCollectionStateStub = new UseCollectionStateStub()
           .withState(initialCollection);
@@ -113,9 +113,9 @@ describe('UseTreeViewFilterEvent', () => {
         // arrange
         const newFilter = filterChange;
         const initialFilter = new FilterResultStub().withSomeMatches();
-        const filterStub = new UserFilterStub();
+        const filterStub = new FilterContextStub();
         const newCollection = new CategoryCollectionStateStub()
-          .withFilter(filterStub.withCurrentFilterResult(initialFilter));
+          .withFilter(filterStub.withCurrentFilter(initialFilter));
         const initialCollection = new CategoryCollectionStateStub();
         const useCollectionStateStub = new UseCollectionStateStub()
           .withState(initialCollection);
@@ -170,8 +170,8 @@ function mountWrapperComponent(options?: {
 }
 
 type FilterChangeTestScenario = (
-  result: IFilterChangeDetails,
-  filter: IFilterResult | undefined,
+  result: FilterChangeDetails,
+  filter: FilterResult | undefined,
 ) => Promise<{
   readonly event: Ref<TreeViewFilterEvent | undefined>,
 }>;
diff --git a/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts b/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts
index 986c0e79..bdb197f8 100644
--- a/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts
+++ b/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts
@@ -1,5 +1,4 @@
 import { IApplicationCode } from '@/application/Context/State/Code/IApplicationCode';
-import { IUserFilter } from '@/application/Context/State/Filter/IUserFilter';
 import { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import { IScript } from '@/domain/IScript';
@@ -7,9 +6,10 @@ import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { UserSelection } from '@/application/Context/State/Selection/UserSelection';
 import { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
+import { FilterContext } from '@/application/Context/State/Filter/FilterContext';
 import { CategoryCollectionStub } from './CategoryCollectionStub';
 import { UserSelectionStub } from './UserSelectionStub';
-import { UserFilterStub } from './UserFilterStub';
+import { FilterContextStub } from './FilterContextStub';
 import { ApplicationCodeStub } from './ApplicationCodeStub';
 import { CategoryStub } from './CategoryStub';
 import { ScriptSelectionStub } from './ScriptSelectionStub';
@@ -17,7 +17,7 @@ import { ScriptSelectionStub } from './ScriptSelectionStub';
 export class CategoryCollectionStateStub implements ICategoryCollectionState {
   public code: IApplicationCode = new ApplicationCodeStub();
 
-  public filter: IUserFilter = new UserFilterStub();
+  public filter: FilterContext = new FilterContextStub();
 
   public get os(): OperatingSystem {
     return this.collection.os;
@@ -55,7 +55,7 @@ export class CategoryCollectionStateStub implements ICategoryCollectionState {
     return this;
   }
 
-  public withFilter(filter: IUserFilter): this {
+  public withFilter(filter: FilterContext): this {
     this.filter = filter;
     return this;
   }
@@ -69,7 +69,7 @@ export class CategoryCollectionStateStub implements ICategoryCollectionState {
     );
   }
 
-  public withSelection(selection: UserSelection) {
+  public withSelection(selection: UserSelection): this {
     this.selection = selection;
     return this;
   }
diff --git a/tests/unit/shared/Stubs/CategoryStub.ts b/tests/unit/shared/Stubs/CategoryStub.ts
index 95fe0af6..e1267c33 100644
--- a/tests/unit/shared/Stubs/CategoryStub.ts
+++ b/tests/unit/shared/Stubs/CategoryStub.ts
@@ -10,7 +10,7 @@ export class CategoryStub extends BaseEntity<number> implements ICategory {
 
   public readonly scripts = new Array<IScript>();
 
-  public readonly docs = new Array<string>();
+  public docs: readonly string[] = new Array<string>();
 
   private allScriptsRecursively: (readonly IScript[]) | undefined;
 
@@ -82,4 +82,9 @@ export class CategoryStub extends BaseEntity<number> implements ICategory {
     this.name = categoryName;
     return this;
   }
+
+  public withDocs(docs: readonly string[]): this {
+    this.docs = docs;
+    return this;
+  }
 }
diff --git a/tests/unit/shared/Stubs/FilterChangeDetailsStub.ts b/tests/unit/shared/Stubs/FilterChangeDetailsStub.ts
index da741b11..b4efb078 100644
--- a/tests/unit/shared/Stubs/FilterChangeDetailsStub.ts
+++ b/tests/unit/shared/Stubs/FilterChangeDetailsStub.ts
@@ -1,9 +1,9 @@
 import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
-import { FilterAction, IFilterChangeDetails, IFilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import type { FilterAction, FilterChangeDetails, FilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 
-export class FilterChangeDetailsStub implements IFilterChangeDetails {
-  public static forApply(filter: IFilterResult) {
+export class FilterChangeDetailsStub implements FilterChangeDetails {
+  public static forApply(filter: FilterResult) {
     return new FilterChangeDetailsStub({
       type: FilterActionType.Apply,
       filter,
@@ -20,7 +20,7 @@ export class FilterChangeDetailsStub implements IFilterChangeDetails {
     public readonly action: FilterAction,
   ) { /* Private constructor to enforce factory methods */ }
 
-  visit(visitor: IFilterChangeDetailsVisitor): void {
+  visit(visitor: FilterChangeDetailsVisitor): void {
     if (this.action.type === FilterActionType.Apply) {
       if (visitor.onApply) {
         visitor.onApply(this.action.filter);
diff --git a/tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub.ts b/tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub.ts
index 8ee90a76..dabe554a 100644
--- a/tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub.ts
+++ b/tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub.ts
@@ -1,18 +1,21 @@
-import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
-import { IFilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import type { FilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 
-export class FilterChangeDetailsVisitorStub implements IFilterChangeDetailsVisitor {
-  public readonly visitedEvents = new Array<FilterActionType>();
-
-  public readonly visitedResults = new Array<IFilterResult>();
-
-  onClear(): void {
-    this.visitedEvents.push(FilterActionType.Clear);
+export class FilterChangeDetailsVisitorStub
+  extends StubWithObservableMethodCalls<Required<FilterChangeDetailsVisitor>>
+  implements FilterChangeDetailsVisitor {
+  public onClear(): void {
+    this.registerMethodCall({
+      methodName: 'onClear',
+      args: [],
+    });
   }
 
-  onApply(filter: IFilterResult): void {
-    this.visitedEvents.push(FilterActionType.Apply);
-    this.visitedResults.push(filter);
+  public onApply(filter: FilterResult): void {
+    this.registerMethodCall({
+      methodName: 'onApply',
+      args: [filter],
+    });
   }
 }
diff --git a/tests/unit/shared/Stubs/FilterContextStub.ts b/tests/unit/shared/Stubs/FilterContextStub.ts
new file mode 100644
index 00000000..6ba05c40
--- /dev/null
+++ b/tests/unit/shared/Stubs/FilterContextStub.ts
@@ -0,0 +1,55 @@
+import { FilterContext } from '@/application/Context/State/Filter/FilterContext';
+import { IEventSource } from '@/infrastructure/Events/IEventSource';
+import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
+import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import { FilterResultStub } from './FilterResultStub';
+import { EventSourceStub } from './EventSourceStub';
+import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
+
+export enum FilterMethod {
+  ApplyFilter,
+  ClearFilter,
+}
+
+export class FilterContextStub
+  extends StubWithObservableMethodCalls<FilterContext>
+  implements FilterContext {
+  private readonly filterChangedSource = new EventSourceStub<FilterChangeDetails>();
+
+  public currentFilter: FilterResult | undefined = new FilterResultStub();
+
+  public filterChanged: IEventSource<FilterChangeDetails> = this.filterChangedSource;
+
+  public notifyFilterChange(change: FilterChangeDetails): void {
+    this.filterChangedSource.notify(change);
+    if (change.action.type === FilterActionType.Apply) {
+      this.currentFilter = change.action.filter;
+    } else {
+      this.currentFilter = undefined;
+    }
+  }
+
+  public withNoCurrentFilter(): this {
+    return this.withCurrentFilter(undefined);
+  }
+
+  public withCurrentFilter(filter: FilterResult | undefined): this {
+    this.currentFilter = filter;
+    return this;
+  }
+
+  public applyFilter(...args: Parameters<FilterContext['applyFilter']>): void {
+    this.registerMethodCall({
+      methodName: 'applyFilter',
+      args: [...args],
+    });
+  }
+
+  public clearFilter(): void {
+    this.registerMethodCall({
+      methodName: 'clearFilter',
+      args: [],
+    });
+  }
+}
diff --git a/tests/unit/shared/Stubs/FilterResultStub.ts b/tests/unit/shared/Stubs/FilterResultStub.ts
index 30154fa7..b61c0d6f 100644
--- a/tests/unit/shared/Stubs/FilterResultStub.ts
+++ b/tests/unit/shared/Stubs/FilterResultStub.ts
@@ -1,10 +1,10 @@
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
-import { ICategory } from '@/domain/ICategory';
-import { IScript } from '@/domain/IScript';
+import type { ICategory } from '@/domain/ICategory';
+import type { IScript } from '@/domain/IScript';
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { CategoryStub } from './CategoryStub';
 import { ScriptStub } from './ScriptStub';
 
-export class FilterResultStub implements IFilterResult {
+export class FilterResultStub implements FilterResult {
   public categoryMatches: readonly ICategory[] = [];
 
   public scriptMatches: readonly IScript[] = [];
diff --git a/tests/unit/shared/Stubs/FilterStrategyStub.ts b/tests/unit/shared/Stubs/FilterStrategyStub.ts
new file mode 100644
index 00000000..71c7117d
--- /dev/null
+++ b/tests/unit/shared/Stubs/FilterStrategyStub.ts
@@ -0,0 +1,24 @@
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import { FilterStrategy } from '@/application/Context/State/Filter/Strategy/FilterStrategy';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { FilterResultStub } from './FilterResultStub';
+import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
+
+export class FilterStrategyStub
+  extends StubWithObservableMethodCalls<FilterStrategy>
+  implements FilterStrategy {
+  private predeterminedResult: FilterResult = new FilterResultStub();
+
+  public applyFilter(filter: string, collection: ICategoryCollection): FilterResult {
+    this.registerMethodCall({
+      methodName: 'applyFilter',
+      args: [filter, collection],
+    });
+    return this.predeterminedResult;
+  }
+
+  public withApplyFilterResult(predeterminedResult: FilterResult): this {
+    this.predeterminedResult = predeterminedResult;
+    return this;
+  }
+}
diff --git a/tests/unit/shared/Stubs/ScriptStub.ts b/tests/unit/shared/Stubs/ScriptStub.ts
index 3830bcef..fe4faeb0 100644
--- a/tests/unit/shared/Stubs/ScriptStub.ts
+++ b/tests/unit/shared/Stubs/ScriptStub.ts
@@ -12,7 +12,7 @@ export class ScriptStub extends BaseEntity<string> implements IScript {
     revert: `REM revert-code (${this.id})`,
   };
 
-  public readonly docs = new Array<string>();
+  public docs: readonly string[] = new Array<string>();
 
   public level? = RecommendationLevel.Standard;
 
@@ -60,6 +60,11 @@ export class ScriptStub extends BaseEntity<string> implements IScript {
     return this;
   }
 
+  public withDocs(docs: readonly string[]): this {
+    this.docs = docs;
+    return this;
+  }
+
   public toSelectedScript(): SelectedScriptStub {
     return new SelectedScriptStub(this);
   }
diff --git a/tests/unit/shared/Stubs/UseCollectionStateStub.ts b/tests/unit/shared/Stubs/UseCollectionStateStub.ts
index 53679075..48c4a51c 100644
--- a/tests/unit/shared/Stubs/UseCollectionStateStub.ts
+++ b/tests/unit/shared/Stubs/UseCollectionStateStub.ts
@@ -4,12 +4,12 @@ import {
   StateModifier, useCollectionState,
 } from '@/presentation/components/Shared/Hooks/UseCollectionState';
 import { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
-import { IUserFilter } from '@/application/Context/State/Filter/IUserFilter';
+import { FilterContext } from '@/application/Context/State/Filter/FilterContext';
 import { IApplicationContext } from '@/application/Context/IApplicationContext';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { CategoryCollectionStateStub } from './CategoryCollectionStateStub';
 import { ApplicationContextStub } from './ApplicationContextStub';
-import { UserFilterStub } from './UserFilterStub';
+import { FilterContextStub } from './FilterContextStub';
 import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 
 export class UseCollectionStateStub
@@ -20,7 +20,7 @@ export class UseCollectionStateStub
     new CategoryCollectionStateStub(),
   );
 
-  public withFilter(filter: IUserFilter) {
+  public withFilter(filter: FilterContext) {
     const state = new CategoryCollectionStateStub()
       .withFilter(filter);
     const context = new ApplicationContextStub()
@@ -30,9 +30,9 @@ export class UseCollectionStateStub
       .withContext(context);
   }
 
-  public withFilterResult(filterResult: IFilterResult | undefined) {
-    const filter = new UserFilterStub()
-      .withCurrentFilterResult(filterResult);
+  public withFilterResult(filterResult: FilterResult | undefined) {
+    const filter = new FilterContextStub()
+      .withCurrentFilter(filterResult);
     return this.withFilter(filter);
   }
 
diff --git a/tests/unit/shared/Stubs/UserFilterStub.ts b/tests/unit/shared/Stubs/UserFilterStub.ts
deleted file mode 100644
index 464aee53..00000000
--- a/tests/unit/shared/Stubs/UserFilterStub.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
-import { IUserFilter } from '@/application/Context/State/Filter/IUserFilter';
-import { IEventSource } from '@/infrastructure/Events/IEventSource';
-import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
-import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
-import { FilterResultStub } from './FilterResultStub';
-import { EventSourceStub } from './EventSourceStub';
-
-export enum UserFilterMethod {
-  ApplyFilter,
-  ClearFilter,
-}
-
-export class UserFilterStub implements IUserFilter {
-  private readonly filterChangedSource = new EventSourceStub<IFilterChangeDetails>();
-
-  public readonly callHistory = new Array<UserFilterMethod>();
-
-  public currentFilter: IFilterResult | undefined = new FilterResultStub();
-
-  public filterChanged: IEventSource<IFilterChangeDetails> = this.filterChangedSource;
-
-  public notifyFilterChange(change: IFilterChangeDetails) {
-    this.filterChangedSource.notify(change);
-    if (change.action.type === FilterActionType.Apply) {
-      this.currentFilter = change.action.filter;
-    } else {
-      this.currentFilter = undefined;
-    }
-  }
-
-  public withNoCurrentFilter() {
-    return this.withCurrentFilterResult(undefined);
-  }
-
-  public withCurrentFilterResult(filter: IFilterResult | undefined) {
-    this.currentFilter = filter;
-    return this;
-  }
-
-  public applyFilter(): void {
-    this.callHistory.push(UserFilterMethod.ApplyFilter);
-  }
-
-  public clearFilter(): void {
-    this.callHistory.push(UserFilterMethod.ClearFilter);
-  }
-}