diff --git a/docs/application.md b/docs/application.md
index 7c73635e..6e2eb4f8 100644
--- a/docs/application.md
+++ b/docs/application.md
@@ -41,5 +41,5 @@ Application layer compiles templating syntax during parsing to create the end sc
 
 The steps to extend the templating syntax:
 
-1. Add a new parser under [SyntaxParsers](./../src/application/Parser/Script/Compiler/Expressions/SyntaxParsers) where you can look at other parsers to understand more.
-2. Register your in [CompositeExpressionParser](./../src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts).
+1. Add a new parser under [SyntaxParsers](./../src/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers) where you can look at other parsers to understand more.
+2. Register your in [CompositeExpressionParser](./../src/application/Parser/Executable/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts).
diff --git a/docs/collection-files.md b/docs/collection-files.md
index d58d2d1e..f3239728 100644
--- a/docs/collection-files.md
+++ b/docs/collection-files.md
@@ -28,11 +28,20 @@ Related documentation:
 - `scripting:` ***[`ScriptingDefinition`](#scriptingdefinition)*** **(required)**
   - Sets the scripting language for all inline code used within the collection.
 
-### `Category`
+### Executables
+
+An Executable is a logical entity that can
+
+- execute once compiled,
+- include a `docs` property for documentation.
+
+It's either [Category](#category) or a [Script](#script).
+
+#### `Category`
 
 Represents a logical group of scripts and subcategories.
 
-#### `Category` syntax
+##### `Category` syntax
 
 - `category:` *`string`*  **(required)**
   - Name of the category.
@@ -43,7 +52,7 @@ Represents a logical group of scripts and subcategories.
 - `docs`: *`string`* | `[`*`string`*`, ... ]`
   - Markdown-formatted documentation related to the category.
 
-### `Script`
+#### `Script`
 
 Represents an individual tweak.
 
@@ -58,7 +67,7 @@ Types (like [functions](#function)):
 
 📖 For detailed guidelines, see [Script Guidelines](./script-guidelines.md).
 
-#### `Script` syntax
+##### `Script` syntax
 
 - `name`: *`string`* **(required)**
   - Script name.
diff --git a/src/application/Context/State/Code/Event/CodeChangedEvent.ts b/src/application/Context/State/Code/Event/CodeChangedEvent.ts
index b15f0a53..aa99a78e 100644
--- a/src/application/Context/State/Code/Event/CodeChangedEvent.ts
+++ b/src/application/Context/State/Code/Event/CodeChangedEvent.ts
@@ -1,4 +1,4 @@
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import type { ICodePosition } from '@/application/Context/State/Code/Position/ICodePosition';
 import type { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
 import type { ICodeChangedEvent } from './ICodeChangedEvent';
@@ -6,13 +6,13 @@ import type { ICodeChangedEvent } from './ICodeChangedEvent';
 export class CodeChangedEvent implements ICodeChangedEvent {
   public readonly code: string;
 
-  public readonly addedScripts: ReadonlyArray<IScript>;
+  public readonly addedScripts: ReadonlyArray<Script>;
 
-  public readonly removedScripts: ReadonlyArray<IScript>;
+  public readonly removedScripts: ReadonlyArray<Script>;
 
-  public readonly changedScripts: ReadonlyArray<IScript>;
+  public readonly changedScripts: ReadonlyArray<Script>;
 
-  private readonly scripts: Map<IScript, ICodePosition>;
+  private readonly scripts: Map<Script, ICodePosition>;
 
   constructor(
     code: string,
@@ -25,7 +25,7 @@ export class CodeChangedEvent implements ICodeChangedEvent {
     this.addedScripts = selectIfNotExists(newScripts, oldScripts);
     this.removedScripts = selectIfNotExists(oldScripts, newScripts);
     this.changedScripts = getChangedScripts(oldScripts, newScripts);
-    this.scripts = new Map<IScript, ICodePosition>();
+    this.scripts = new Map<Script, ICodePosition>();
     scripts.forEach((position, selection) => {
       this.scripts.set(selection.script, position);
     });
@@ -35,7 +35,7 @@ export class CodeChangedEvent implements ICodeChangedEvent {
     return this.scripts.size === 0;
   }
 
-  public getScriptPositionInCode(script: IScript): ICodePosition {
+  public getScriptPositionInCode(script: Script): ICodePosition {
     return this.getPositionById(script.id);
   }
 
@@ -65,7 +65,7 @@ function ensureAllPositionsExist(script: string, positions: ReadonlyArray<ICodeP
 function getChangedScripts(
   oldScripts: ReadonlyArray<SelectedScript>,
   newScripts: ReadonlyArray<SelectedScript>,
-): ReadonlyArray<IScript> {
+): ReadonlyArray<Script> {
   return newScripts
     .filter((newScript) => oldScripts.find((oldScript) => oldScript.id === newScript.id
       && oldScript.revert !== newScript.revert))
diff --git a/src/application/Context/State/Code/Event/ICodeChangedEvent.ts b/src/application/Context/State/Code/Event/ICodeChangedEvent.ts
index 612787f8..abc66b7d 100644
--- a/src/application/Context/State/Code/Event/ICodeChangedEvent.ts
+++ b/src/application/Context/State/Code/Event/ICodeChangedEvent.ts
@@ -1,11 +1,11 @@
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import type { ICodePosition } from '@/application/Context/State/Code/Position/ICodePosition';
 
 export interface ICodeChangedEvent {
   readonly code: string;
-  readonly addedScripts: ReadonlyArray<IScript>;
-  readonly removedScripts: ReadonlyArray<IScript>;
-  readonly changedScripts: ReadonlyArray<IScript>;
+  readonly addedScripts: ReadonlyArray<Script>;
+  readonly removedScripts: ReadonlyArray<Script>;
+  readonly changedScripts: ReadonlyArray<Script>;
   isEmpty(): boolean;
-  getScriptPositionInCode(script: IScript): ICodePosition;
+  getScriptPositionInCode(script: Script): ICodePosition;
 }
diff --git a/src/application/Context/State/Filter/Result/AppliedFilterResult.ts b/src/application/Context/State/Filter/Result/AppliedFilterResult.ts
index b7df728c..7cdecd51 100644
--- a/src/application/Context/State/Filter/Result/AppliedFilterResult.ts
+++ b/src/application/Context/State/Filter/Result/AppliedFilterResult.ts
@@ -1,11 +1,11 @@
-import type { IScript } from '@/domain/IScript';
-import type { ICategory } from '@/domain/ICategory';
+import type { Script } from '@/domain/Executables/Script/Script';
+import type { Category } from '@/domain/Executables/Category/Category';
 import type { FilterResult } from './FilterResult';
 
 export class AppliedFilterResult implements FilterResult {
   constructor(
-    public readonly scriptMatches: ReadonlyArray<IScript>,
-    public readonly categoryMatches: ReadonlyArray<ICategory>,
+    public readonly scriptMatches: ReadonlyArray<Script>,
+    public readonly categoryMatches: ReadonlyArray<Category>,
     public readonly query: string,
   ) {
     if (!query) { throw new Error('Query is empty or undefined'); }
diff --git a/src/application/Context/State/Filter/Result/FilterResult.ts b/src/application/Context/State/Filter/Result/FilterResult.ts
index a12a13b4..6efa5e9a 100644
--- a/src/application/Context/State/Filter/Result/FilterResult.ts
+++ b/src/application/Context/State/Filter/Result/FilterResult.ts
@@ -1,8 +1,9 @@
-import type { IScript, ICategory } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
+import type { Script } from '@/domain/Executables/Script/Script';
 
 export interface FilterResult {
-  readonly categoryMatches: ReadonlyArray<ICategory>;
-  readonly scriptMatches: ReadonlyArray<IScript>;
+  readonly categoryMatches: ReadonlyArray<Category>;
+  readonly scriptMatches: ReadonlyArray<Script>;
   readonly query: string;
   hasAnyMatches(): boolean;
 }
diff --git a/src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts b/src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts
index c9c978ee..bb3bfb04 100644
--- a/src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts
+++ b/src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts
@@ -1,7 +1,8 @@
-import type { ICategory, IScript } from '@/domain/ICategory';
-import type { IScriptCode } from '@/domain/IScriptCode';
-import type { IDocumentable } from '@/domain/IDocumentable';
+import type { Category } from '@/domain/Executables/Category/Category';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
+import type { Documentable } from '@/domain/Executables/Documentable';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { AppliedFilterResult } from '../Result/AppliedFilterResult';
 import type { FilterStrategy } from './FilterStrategy';
 import type { FilterResult } from '../Result/FilterResult';
@@ -24,7 +25,7 @@ export class LinearFilterStrategy implements FilterStrategy {
 }
 
 function matchesCategory(
-  category: ICategory,
+  category: Category,
   filterLowercase: string,
 ): boolean {
   return matchesAny(
@@ -34,7 +35,7 @@ function matchesCategory(
 }
 
 function matchesScript(
-  script: IScript,
+  script: Script,
   filterLowercase: string,
 ): boolean {
   return matchesAny(
@@ -58,7 +59,7 @@ function matchName(
 }
 
 function matchCode(
-  code: IScriptCode,
+  code: ScriptCode,
   filterLowercase: string,
 ): boolean {
   if (code.execute.toLowerCase().includes(filterLowercase)) {
@@ -71,7 +72,7 @@ function matchCode(
 }
 
 function matchDocumentation(
-  documentable: IDocumentable,
+  documentable: Documentable,
   filterLowercase: string,
 ): boolean {
   return documentable.docs.some(
diff --git a/src/application/Context/State/Selection/Category/CategorySelection.ts b/src/application/Context/State/Selection/Category/CategorySelection.ts
index 1911dcd8..2e348f6b 100644
--- a/src/application/Context/State/Selection/Category/CategorySelection.ts
+++ b/src/application/Context/State/Selection/Category/CategorySelection.ts
@@ -1,9 +1,9 @@
-import type { ICategory } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
 import type { CategorySelectionChangeCommand } from './CategorySelectionChange';
 
 export interface ReadonlyCategorySelection {
-  areAllScriptsSelected(category: ICategory): boolean;
-  isAnyScriptSelected(category: ICategory): boolean;
+  areAllScriptsSelected(category: Category): boolean;
+  isAnyScriptSelected(category: Category): boolean;
 }
 
 export interface CategorySelection extends ReadonlyCategorySelection {
diff --git a/src/application/Context/State/Selection/Category/ScriptToCategorySelectionMapper.ts b/src/application/Context/State/Selection/Category/ScriptToCategorySelectionMapper.ts
index e06693b3..a856b0ea 100644
--- a/src/application/Context/State/Selection/Category/ScriptToCategorySelectionMapper.ts
+++ b/src/application/Context/State/Selection/Category/ScriptToCategorySelectionMapper.ts
@@ -1,4 +1,4 @@
-import type { ICategory } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
 import type { CategorySelectionChange, CategorySelectionChangeCommand } from './CategorySelectionChange';
 import type { CategorySelection } from './CategorySelection';
@@ -13,7 +13,7 @@ export class ScriptToCategorySelectionMapper implements CategorySelection {
 
   }
 
-  public areAllScriptsSelected(category: ICategory): boolean {
+  public areAllScriptsSelected(category: Category): boolean {
     const { selectedScripts } = this.scriptSelection;
     if (selectedScripts.length === 0) {
       return false;
@@ -27,7 +27,7 @@ export class ScriptToCategorySelectionMapper implements CategorySelection {
     );
   }
 
-  public isAnyScriptSelected(category: ICategory): boolean {
+  public isAnyScriptSelected(category: Category): boolean {
     const { selectedScripts } = this.scriptSelection;
     if (selectedScripts.length === 0) {
       return false;
diff --git a/src/application/Context/State/Selection/Script/DebouncedScriptSelection.ts b/src/application/Context/State/Selection/Script/DebouncedScriptSelection.ts
index 5ac98f7f..79a7dd46 100644
--- a/src/application/Context/State/Selection/Script/DebouncedScriptSelection.ts
+++ b/src/application/Context/State/Selection/Script/DebouncedScriptSelection.ts
@@ -1,5 +1,5 @@
 import { InMemoryRepository } from '@/infrastructure/Repository/InMemoryRepository';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { EventSource } from '@/infrastructure/Events/EventSource';
 import type { ReadonlyRepository, Repository } from '@/application/Repository/Repository';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
@@ -80,7 +80,7 @@ export class DebouncedScriptSelection implements ScriptSelection {
     });
   }
 
-  public selectOnly(scripts: readonly IScript[]): void {
+  public selectOnly(scripts: readonly Script[]): void {
     assertNonEmptyScriptSelection(scripts);
     this.processChanges({
       changes: [
@@ -145,7 +145,7 @@ export class DebouncedScriptSelection implements ScriptSelection {
   }
 }
 
-function assertNonEmptyScriptSelection(selectedItems: readonly IScript[]) {
+function assertNonEmptyScriptSelection(selectedItems: readonly Script[]) {
   if (selectedItems.length === 0) {
     throw new Error('Provided script array is empty. To deselect all scripts, please use the deselectAll() method instead.');
   }
@@ -153,7 +153,7 @@ function assertNonEmptyScriptSelection(selectedItems: readonly IScript[]) {
 
 function getScriptIdsToBeSelected(
   existingItems: ReadonlyRepository<string, SelectedScript>,
-  desiredScripts: readonly IScript[],
+  desiredScripts: readonly Script[],
 ): string[] {
   return desiredScripts
     .filter((script) => !existingItems.exists(script.id))
@@ -162,7 +162,7 @@ function getScriptIdsToBeSelected(
 
 function getScriptIdsToBeDeselected(
   existingItems: ReadonlyRepository<string, SelectedScript>,
-  desiredScripts: readonly IScript[],
+  desiredScripts: readonly Script[],
 ): string[] {
   return existingItems
     .getItems()
diff --git a/src/application/Context/State/Selection/Script/ScriptSelection.ts b/src/application/Context/State/Selection/Script/ScriptSelection.ts
index e2b50f72..ebd7f3e9 100644
--- a/src/application/Context/State/Selection/Script/ScriptSelection.ts
+++ b/src/application/Context/State/Selection/Script/ScriptSelection.ts
@@ -1,5 +1,5 @@
 import type { IEventSource } from '@/infrastructure/Events/IEventSource';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import type { SelectedScript } from './SelectedScript';
 import type { ScriptSelectionChangeCommand } from './ScriptSelectionChange';
 
@@ -10,7 +10,7 @@ export interface ReadonlyScriptSelection {
 }
 
 export interface ScriptSelection extends ReadonlyScriptSelection {
-  selectOnly(scripts: readonly IScript[]): void;
+  selectOnly(scripts: readonly Script[]): void;
   selectAll(): void;
   deselectAll(): void;
   processChanges(action: ScriptSelectionChangeCommand): void;
diff --git a/src/application/Context/State/Selection/Script/SelectedScript.ts b/src/application/Context/State/Selection/Script/SelectedScript.ts
index 05e40087..c0059f6e 100644
--- a/src/application/Context/State/Selection/Script/SelectedScript.ts
+++ b/src/application/Context/State/Selection/Script/SelectedScript.ts
@@ -1,9 +1,9 @@
 import type { IEntity } from '@/infrastructure/Entity/IEntity';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 
-type ScriptId = IScript['id'];
+type ScriptId = Script['id'];
 
 export interface SelectedScript extends IEntity<ScriptId> {
-  readonly script: IScript;
+  readonly script: Script;
   readonly revert: boolean;
 }
diff --git a/src/application/Context/State/Selection/Script/UserSelectedScript.ts b/src/application/Context/State/Selection/Script/UserSelectedScript.ts
index af40d00f..315da002 100644
--- a/src/application/Context/State/Selection/Script/UserSelectedScript.ts
+++ b/src/application/Context/State/Selection/Script/UserSelectedScript.ts
@@ -1,12 +1,12 @@
 import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import type { SelectedScript } from './SelectedScript';
 
 type SelectedScriptId = SelectedScript['id'];
 
 export class UserSelectedScript extends BaseEntity<SelectedScriptId> {
   constructor(
-    public readonly script: IScript,
+    public readonly script: Script,
     public readonly revert: boolean,
   ) {
     super(script.id);
diff --git a/src/application/Parser/CategoryCollectionParser.ts b/src/application/Parser/CategoryCollectionParser.ts
index b6d1b1e6..8aef0a80 100644
--- a/src/application/Parser/CategoryCollectionParser.ts
+++ b/src/application/Parser/CategoryCollectionParser.ts
@@ -4,20 +4,21 @@ import type { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { CategoryCollection } from '@/domain/CategoryCollection';
 import type { ProjectDetails } from '@/domain/Project/ProjectDetails';
 import { createEnumParser } from '../Common/Enum';
-import { parseCategory } from './CategoryParser';
-import { CategoryCollectionParseContext } from './Script/CategoryCollectionParseContext';
+import { parseCategory } from './Executable/CategoryParser';
 import { ScriptingDefinitionParser } from './ScriptingDefinition/ScriptingDefinitionParser';
+import { createCollectionUtilities, type CategoryCollectionSpecificUtilitiesFactory } from './Executable/CategoryCollectionSpecificUtilities';
 
 export function parseCategoryCollection(
   content: CollectionData,
   projectDetails: ProjectDetails,
   osParser = createEnumParser(OperatingSystem),
+  createUtilities: CategoryCollectionSpecificUtilitiesFactory = createCollectionUtilities,
 ): ICategoryCollection {
   validate(content);
   const scripting = new ScriptingDefinitionParser()
     .parse(content.scripting, projectDetails);
-  const context = new CategoryCollectionParseContext(content.functions, scripting);
-  const categories = content.actions.map((action) => parseCategory(action, context));
+  const utilities = createUtilities(content.functions, scripting);
+  const categories = content.actions.map((action) => parseCategory(action, utilities));
   const os = osParser.parseEnum(content.os, 'os');
   const collection = new CategoryCollection(
     os,
diff --git a/src/application/Parser/Executable/CategoryCollectionSpecificUtilities.ts b/src/application/Parser/Executable/CategoryCollectionSpecificUtilities.ts
new file mode 100644
index 00000000..17a6e0d5
--- /dev/null
+++ b/src/application/Parser/Executable/CategoryCollectionSpecificUtilities.ts
@@ -0,0 +1,32 @@
+import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
+import type { FunctionData } from '@/application/collections/';
+import { ScriptCompiler } from './Script/Compiler/ScriptCompiler';
+import { SyntaxFactory } from './Script/Validation/Syntax/SyntaxFactory';
+import type { IScriptCompiler } from './Script/Compiler/IScriptCompiler';
+import type { ILanguageSyntax } from './Script/Validation/Syntax/ILanguageSyntax';
+import type { ISyntaxFactory } from './Script/Validation/Syntax/ISyntaxFactory';
+
+export interface CategoryCollectionSpecificUtilities {
+  readonly compiler: IScriptCompiler;
+  readonly syntax: ILanguageSyntax;
+}
+
+export const createCollectionUtilities: CategoryCollectionSpecificUtilitiesFactory = (
+  functionsData: ReadonlyArray<FunctionData> | undefined,
+  scripting: IScriptingDefinition,
+  syntaxFactory: ISyntaxFactory = new SyntaxFactory(),
+) => {
+  const syntax = syntaxFactory.create(scripting.language);
+  return {
+    compiler: new ScriptCompiler(functionsData ?? [], syntax),
+    syntax,
+  };
+};
+
+export interface CategoryCollectionSpecificUtilitiesFactory {
+  (
+    functionsData: ReadonlyArray<FunctionData> | undefined,
+    scripting: IScriptingDefinition,
+    syntaxFactory?: ISyntaxFactory,
+  ): CategoryCollectionSpecificUtilities;
+}
diff --git a/src/application/Parser/CategoryParser.ts b/src/application/Parser/Executable/CategoryParser.ts
similarity index 53%
rename from src/application/Parser/CategoryParser.ts
rename to src/application/Parser/Executable/CategoryParser.ts
index 1eaa3fbc..30dd5eb0 100644
--- a/src/application/Parser/CategoryParser.ts
+++ b/src/application/Parser/Executable/CategoryParser.ts
@@ -1,35 +1,35 @@
 import type {
-  CategoryData, ScriptData, CategoryOrScriptData,
+  CategoryData, ScriptData, ExecutableData,
 } from '@/application/collections/';
-import { Script } from '@/domain/Script';
-import { Category } from '@/domain/Category';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import type { ICategory } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
+import { CollectionCategory } from '@/domain/Executables/Category/CollectionCategory';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { parseDocs, type DocsParser } from './DocumentationParser';
 import { parseScript, type ScriptParser } from './Script/ScriptParser';
-import { createNodeDataValidator, type NodeDataValidator, type NodeDataValidatorFactory } from './NodeValidation/NodeDataValidator';
-import { NodeDataType } from './NodeValidation/NodeDataType';
-import type { ICategoryCollectionParseContext } from './Script/ICategoryCollectionParseContext';
+import { createExecutableDataValidator, type ExecutableValidator, type ExecutableValidatorFactory } from './Validation/ExecutableValidator';
+import { ExecutableType } from './Validation/ExecutableType';
+import type { CategoryCollectionSpecificUtilities } from './CategoryCollectionSpecificUtilities';
 
 let categoryIdCounter = 0;
 
 export function parseCategory(
   category: CategoryData,
-  context: ICategoryCollectionParseContext,
-  utilities: CategoryParserUtilities = DefaultCategoryParserUtilities,
+  collectionUtilities: CategoryCollectionSpecificUtilities,
+  categoryUtilities: CategoryParserUtilities = DefaultCategoryParserUtilities,
 ): Category {
   return parseCategoryRecursively({
     categoryData: category,
-    context,
-    utilities,
+    collectionUtilities,
+    categoryUtilities,
   });
 }
 
 interface CategoryParseContext {
   readonly categoryData: CategoryData;
-  readonly context: ICategoryCollectionParseContext;
+  readonly collectionUtilities: CategoryCollectionSpecificUtilities;
   readonly parentCategory?: CategoryData;
-  readonly utilities: CategoryParserUtilities;
+  readonly categoryUtilities: CategoryParserUtilities;
 }
 
 function parseCategoryRecursively(
@@ -41,24 +41,24 @@ function parseCategoryRecursively(
     subscripts: new Array<Script>(),
   };
   for (const data of context.categoryData.children) {
-    parseNode({
-      nodeData: data,
+    parseExecutable({
+      data,
       children,
       parent: context.categoryData,
-      utilities: context.utilities,
-      context: context.context,
+      categoryUtilities: context.categoryUtilities,
+      collectionUtilities: context.collectionUtilities,
     });
   }
   try {
-    return context.utilities.createCategory({
+    return context.categoryUtilities.createCategory({
       id: categoryIdCounter++,
       name: context.categoryData.category,
-      docs: context.utilities.parseDocs(context.categoryData),
+      docs: context.categoryUtilities.parseDocs(context.categoryData),
       subcategories: children.subcategories,
       scripts: children.subscripts,
     });
   } catch (error) {
-    throw context.utilities.wrapError(
+    throw context.categoryUtilities.wrapError(
       error,
       validator.createContextualErrorMessage('Failed to parse category.'),
     );
@@ -67,12 +67,12 @@ function parseCategoryRecursively(
 
 function ensureValidCategory(
   context: CategoryParseContext,
-): NodeDataValidator {
+): ExecutableValidator {
   const category = context.categoryData;
-  const validator: NodeDataValidator = context.utilities.createValidator({
-    type: NodeDataType.Category,
-    selfNode: context.categoryData,
-    parentNode: context.parentCategory,
+  const validator: ExecutableValidator = context.categoryUtilities.createValidator({
+    type: ExecutableType.Category,
+    self: context.categoryData,
+    parentCategory: context.parentCategory,
   });
   validator.assertDefined(category);
   validator.assertValidName(category.category);
@@ -88,44 +88,43 @@ interface CategoryChildren {
   readonly subscripts: Script[];
 }
 
-interface NodeParseContext {
-  readonly nodeData: CategoryOrScriptData;
+interface ExecutableParseContext {
+  readonly data: ExecutableData;
   readonly children: CategoryChildren;
   readonly parent: CategoryData;
-  readonly context: ICategoryCollectionParseContext;
-
-  readonly utilities: CategoryParserUtilities;
+  readonly collectionUtilities: CategoryCollectionSpecificUtilities;
+  readonly categoryUtilities: CategoryParserUtilities;
 }
 
-function parseNode(context: NodeParseContext) {
-  const validator: NodeDataValidator = context.utilities.createValidator({
-    selfNode: context.nodeData,
-    parentNode: context.parent,
+function parseExecutable(context: ExecutableParseContext) {
+  const validator: ExecutableValidator = context.categoryUtilities.createValidator({
+    self: context.data,
+    parentCategory: context.parent,
   });
-  validator.assertDefined(context.nodeData);
+  validator.assertDefined(context.data);
   validator.assert(
-    () => isCategory(context.nodeData) || isScript(context.nodeData),
-    'Node is neither a category or a script.',
+    () => isCategory(context.data) || isScript(context.data),
+    'Executable is neither a category or a script.',
   );
-  if (isCategory(context.nodeData)) {
+  if (isCategory(context.data)) {
     const subCategory = parseCategoryRecursively({
-      categoryData: context.nodeData,
-      context: context.context,
+      categoryData: context.data,
+      collectionUtilities: context.collectionUtilities,
       parentCategory: context.parent,
-      utilities: context.utilities,
+      categoryUtilities: context.categoryUtilities,
     });
     context.children.subcategories.push(subCategory);
   } else { // A script
-    const script = context.utilities.parseScript(context.nodeData, context.context);
+    const script = context.categoryUtilities.parseScript(context.data, context.collectionUtilities);
     context.children.subscripts.push(script);
   }
 }
 
-function isScript(data: CategoryOrScriptData): data is ScriptData {
+function isScript(data: ExecutableData): data is ScriptData {
   return hasCode(data) || hasCall(data);
 }
 
-function isCategory(data: CategoryOrScriptData): data is CategoryData {
+function isCategory(data: ExecutableData): data is CategoryData {
   return hasProperty(data, 'category');
 }
 
@@ -151,21 +150,21 @@ function hasProperty(
 }
 
 export type CategoryFactory = (
-  ...parameters: ConstructorParameters<typeof Category>
-) => ICategory;
+  ...parameters: ConstructorParameters<typeof CollectionCategory>
+) => Category;
 
 interface CategoryParserUtilities {
   readonly createCategory: CategoryFactory;
   readonly wrapError: ErrorWithContextWrapper;
-  readonly createValidator: NodeDataValidatorFactory;
+  readonly createValidator: ExecutableValidatorFactory;
   readonly parseScript: ScriptParser;
   readonly parseDocs: DocsParser;
 }
 
 const DefaultCategoryParserUtilities: CategoryParserUtilities = {
-  createCategory: (...parameters) => new Category(...parameters),
+  createCategory: (...parameters) => new CollectionCategory(...parameters),
   wrapError: wrapErrorWithAdditionalContext,
-  createValidator: createNodeDataValidator,
+  createValidator: createExecutableDataValidator,
   parseScript,
   parseDocs,
 };
diff --git a/src/application/Parser/DocumentationParser.ts b/src/application/Parser/Executable/DocumentationParser.ts
similarity index 100%
rename from src/application/Parser/DocumentationParser.ts
rename to src/application/Parser/Executable/DocumentationParser.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Expression/Expression.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Expression/Expression.ts
similarity index 97%
rename from src/application/Parser/Script/Compiler/Expressions/Expression/Expression.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Expression/Expression.ts
index 8614ca64..671a6545 100644
--- a/src/application/Parser/Script/Compiler/Expressions/Expression/Expression.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Expressions/Expression/Expression.ts
@@ -1,4 +1,4 @@
-import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { FunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection';
 import { FunctionCallArgumentCollection } from '../../Function/Call/Argument/FunctionCallArgumentCollection';
 import { ExpressionEvaluationContext, type IExpressionEvaluationContext } from './ExpressionEvaluationContext';
 import { ExpressionPosition } from './ExpressionPosition';
diff --git a/src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Expression/IExpression.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Expression/IExpression.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Expression/IExpression.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Expression/IExpression.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler.ts
similarity index 98%
rename from src/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler.ts
index 30664af0..f696cdf8 100644
--- a/src/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler.ts
@@ -1,4 +1,4 @@
-import { type IExpressionEvaluationContext, ExpressionEvaluationContext } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
+import { type IExpressionEvaluationContext, ExpressionEvaluationContext } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
 import { CompositeExpressionParser } from './Parser/CompositeExpressionParser';
 import type { IReadOnlyFunctionCallArgumentCollection } from '../Function/Call/Argument/IFunctionCallArgumentCollection';
 import type { IExpressionsCompiler } from './IExpressionsCompiler';
diff --git a/src/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/RegexParser.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/RegexParser.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Pipes/IPipe.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipe.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Pipes/IPipe.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipe.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Pipes/IPipelineCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipelineCompiler.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Pipes/IPipelineCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipelineCompiler.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeFactory.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeFactory.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/Pipes/PipelineCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipelineCompiler.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Expressions/Pipes/PipelineCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipelineCompiler.ts
diff --git a/src/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.ts
similarity index 89%
rename from src/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.ts
index ef23b1d6..c9900ca6 100644
--- a/src/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.ts
@@ -1,4 +1,4 @@
-import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
+import { FunctionParameter } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter';
 import { RegexParser, type PrimitiveExpression } from '../Parser/Regex/RegexParser';
 import { ExpressionRegexBuilder } from '../Parser/Regex/ExpressionRegexBuilder';
 
diff --git a/src/application/Parser/Script/Compiler/Expressions/SyntaxParsers/WithParser.ts b/src/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/WithParser.ts
similarity index 95%
rename from src/application/Parser/Script/Compiler/Expressions/SyntaxParsers/WithParser.ts
rename to src/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/WithParser.ts
index be9490b4..d92244c2 100644
--- a/src/application/Parser/Script/Compiler/Expressions/SyntaxParsers/WithParser.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/WithParser.ts
@@ -1,7 +1,7 @@
 // eslint-disable-next-line max-classes-per-file
-import type { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
-import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
-import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
+import type { IExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser';
+import { FunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { FunctionParameter } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter';
 import { ExpressionPosition } from '../Expression/ExpressionPosition';
 import { ExpressionRegexBuilder } from '../Parser/Regex/ExpressionRegexBuilder';
 import { createPositionFromRegexFullMatch } from '../Expression/ExpressionPositionFactory';
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgument.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgument.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgument.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgument.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/CodeSegmentMerger.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/CodeSegmentMerger.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/CodeSegmentMerger.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/CodeSegmentMerger.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext.ts
similarity index 85%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext.ts
index be771431..1c1080fd 100644
--- a/src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext.ts
@@ -1,4 +1,4 @@
-import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
+import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
 import type { FunctionCall } from '../FunctionCall';
 import type { SingleCallCompiler } from './SingleCall/SingleCallCompiler';
 
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler.ts
similarity index 82%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler.ts
index a0ba0969..a004030a 100644
--- a/src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler.ts
@@ -1,4 +1,4 @@
-import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
+import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
 import type { CompiledCode } from './CompiledCode';
 import type { FunctionCall } from '../FunctionCall';
 
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.ts
similarity index 93%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.ts
index 25848a04..0e3c310d 100644
--- a/src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.ts
@@ -1,4 +1,4 @@
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import { NewlineCodeSegmentMerger } from './CodeSegmentJoin/NewlineCodeSegmentMerger';
 import { AdaptiveFunctionCallCompiler } from './SingleCall/AdaptiveFunctionCallCompiler';
 import type { ISharedFunctionCollection } from '../../ISharedFunctionCollection';
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/AdaptiveFunctionCallCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/AdaptiveFunctionCallCompiler.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/AdaptiveFunctionCallCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/AdaptiveFunctionCallCompiler.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy.ts
similarity index 63%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy.ts
index 5eab1dfa..af117c93 100644
--- a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy.ts
@@ -1,5 +1,5 @@
-import type { ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import type { CompiledCode } from '../CompiledCode';
 import type { FunctionCallCompilationContext } from '../FunctionCallCompilationContext';
 
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler.ts
similarity index 56%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler.ts
index deafbd5f..f858a48d 100644
--- a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler.ts
@@ -1,5 +1,5 @@
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
 
 export interface ArgumentCompiler {
   createCompiledNestedCall(
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.ts
similarity index 82%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.ts
index 5e737eac..92ce998c 100644
--- a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.ts
@@ -1,11 +1,11 @@
-import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
-import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
-import { FunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
-import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
-import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import { ParsedFunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/ParsedFunctionCall';
+import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
+import { FunctionCallArgument } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
+import { FunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
+import { ExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import { ParsedFunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/ParsedFunctionCall';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import type { ArgumentCompiler } from './ArgumentCompiler';
 
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.ts
similarity index 74%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.ts
index 051184f5..9f4cfe63 100644
--- a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.ts
@@ -1,8 +1,8 @@
-import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
-import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
-import { FunctionBodyType, type ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import { ExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
+import { FunctionBodyType, type ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
 import type { SingleCallCompilerStrategy } from '../SingleCallCompilerStrategy';
 
 export class InlineFunctionCallCompiler implements SingleCallCompilerStrategy {
diff --git a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler.ts
similarity index 81%
rename from src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler.ts
index 0c8375cb..fd57418a 100644
--- a/src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler.ts
@@ -1,10 +1,10 @@
 import {
   type CallFunctionBody, FunctionBodyType,
   type ISharedFunction,
-} from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+} from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { NestedFunctionArgumentCompiler } from './Argument/NestedFunctionArgumentCompiler';
 import type { SingleCallCompilerStrategy } from '../SingleCallCompilerStrategy';
diff --git a/src/application/Parser/Script/Compiler/Function/Call/FunctionCall.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/FunctionCall.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/FunctionCallParser.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCallParser.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/FunctionCallParser.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCallParser.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Call/ParsedFunctionCall.ts b/src/application/Parser/Executable/Script/Compiler/Function/Call/ParsedFunctionCall.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Call/ParsedFunctionCall.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Call/ParsedFunctionCall.ts
diff --git a/src/application/Parser/Script/Compiler/Function/ISharedFunction.ts b/src/application/Parser/Executable/Script/Compiler/Function/ISharedFunction.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/ISharedFunction.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/ISharedFunction.ts
diff --git a/src/application/Parser/Script/Compiler/Function/ISharedFunctionCollection.ts b/src/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/ISharedFunctionCollection.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection.ts
diff --git a/src/application/Parser/Script/Compiler/Function/ISharedFunctionsParser.ts b/src/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionsParser.ts
similarity index 73%
rename from src/application/Parser/Script/Compiler/Function/ISharedFunctionsParser.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionsParser.ts
index 30e3ecc9..daffe498 100644
--- a/src/application/Parser/Script/Compiler/Function/ISharedFunctionsParser.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionsParser.ts
@@ -1,5 +1,5 @@
 import type { FunctionData } from '@/application/collections/';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 import type { ISharedFunctionCollection } from './ISharedFunctionCollection';
 
 export interface ISharedFunctionsParser {
diff --git a/src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter.ts b/src/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection.ts b/src/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.ts b/src/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameter.ts b/src/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameter.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameter.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameter.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameterCollection.ts b/src/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameterCollection.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameterCollection.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameterCollection.ts
diff --git a/src/application/Parser/Script/Compiler/Function/Shared/ParameterNameValidator.ts b/src/application/Parser/Executable/Script/Compiler/Function/Shared/ParameterNameValidator.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/Shared/ParameterNameValidator.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/Shared/ParameterNameValidator.ts
diff --git a/src/application/Parser/Script/Compiler/Function/SharedFunction.ts b/src/application/Parser/Executable/Script/Compiler/Function/SharedFunction.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/SharedFunction.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/SharedFunction.ts
diff --git a/src/application/Parser/Script/Compiler/Function/SharedFunctionCollection.ts b/src/application/Parser/Executable/Script/Compiler/Function/SharedFunctionCollection.ts
similarity index 100%
rename from src/application/Parser/Script/Compiler/Function/SharedFunctionCollection.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/SharedFunctionCollection.ts
diff --git a/src/application/Parser/Script/Compiler/Function/SharedFunctionsParser.ts b/src/application/Parser/Executable/Script/Compiler/Function/SharedFunctionsParser.ts
similarity index 93%
rename from src/application/Parser/Script/Compiler/Function/SharedFunctionsParser.ts
rename to src/application/Parser/Executable/Script/Compiler/Function/SharedFunctionsParser.ts
index 7d2aa345..a322fc64 100644
--- a/src/application/Parser/Script/Compiler/Function/SharedFunctionsParser.ts
+++ b/src/application/Parser/Executable/Script/Compiler/Function/SharedFunctionsParser.ts
@@ -2,11 +2,11 @@ import type {
   FunctionData, CodeInstruction, CodeFunctionData, CallFunctionData,
   CallInstruction, ParameterDefinitionData,
 } from '@/application/collections/';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
-import { CodeValidator } from '@/application/Parser/Script/Validation/CodeValidator';
-import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
-import { NoDuplicatedLines } from '@/application/Parser/Script/Validation/Rules/NoDuplicatedLines';
-import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
+import { CodeValidator } from '@/application/Parser/Executable/Script/Validation/CodeValidator';
+import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
+import { NoDuplicatedLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines';
+import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
 import { isArray, isNullOrUndefined, isPlainObject } from '@/TypeHelpers';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { createFunctionWithInlineCode, createCallerFunction } from './SharedFunction';
diff --git a/src/application/Parser/Script/Compiler/IScriptCompiler.ts b/src/application/Parser/Executable/Script/Compiler/IScriptCompiler.ts
similarity index 53%
rename from src/application/Parser/Script/Compiler/IScriptCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/IScriptCompiler.ts
index 9db2d593..a411f947 100644
--- a/src/application/Parser/Script/Compiler/IScriptCompiler.ts
+++ b/src/application/Parser/Executable/Script/Compiler/IScriptCompiler.ts
@@ -1,7 +1,7 @@
 import type { ScriptData } from '@/application/collections/';
-import type { IScriptCode } from '@/domain/IScriptCode';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
 
 export interface IScriptCompiler {
   canCompile(script: ScriptData): boolean;
-  compile(script: ScriptData): IScriptCode;
+  compile(script: ScriptData): ScriptCode;
 }
diff --git a/src/application/Parser/Script/Compiler/ScriptCompiler.ts b/src/application/Parser/Executable/Script/Compiler/ScriptCompiler.ts
similarity index 82%
rename from src/application/Parser/Script/Compiler/ScriptCompiler.ts
rename to src/application/Parser/Executable/Script/Compiler/ScriptCompiler.ts
index 84fbdcb8..02271774 100644
--- a/src/application/Parser/Script/Compiler/ScriptCompiler.ts
+++ b/src/application/Parser/Executable/Script/Compiler/ScriptCompiler.ts
@@ -1,11 +1,11 @@
 import type { FunctionData, ScriptData, CallInstruction } from '@/application/collections/';
-import type { IScriptCode } from '@/domain/IScriptCode';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
-import { CodeValidator } from '@/application/Parser/Script/Validation/CodeValidator';
-import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
-import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
+import { CodeValidator } from '@/application/Parser/Executable/Script/Validation/CodeValidator';
+import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
+import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import { createScriptCode, type ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
+import { createScriptCode, type ScriptCodeFactory } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
 import { SharedFunctionsParser } from './Function/SharedFunctionsParser';
 import { FunctionCallSequenceCompiler } from './Function/Call/Compiler/FunctionCallSequenceCompiler';
 import { parseFunctionCalls } from './Function/Call/FunctionCallParser';
@@ -34,7 +34,7 @@ export class ScriptCompiler implements IScriptCompiler {
     return hasCall(script);
   }
 
-  public compile(script: ScriptData): IScriptCode {
+  public compile(script: ScriptData): ScriptCode {
     try {
       if (!hasCall(script)) {
         throw new Error('Script does include any calls.');
diff --git a/src/application/Parser/Script/ScriptParser.ts b/src/application/Parser/Executable/Script/ScriptParser.ts
similarity index 60%
rename from src/application/Parser/Script/ScriptParser.ts
rename to src/application/Parser/Executable/Script/ScriptParser.ts
index bc3ebc5a..cc346622 100644
--- a/src/application/Parser/Script/ScriptParser.ts
+++ b/src/application/Parser/Executable/Script/ScriptParser.ts
@@ -1,44 +1,44 @@
 import type { ScriptData, CodeScriptData, CallScriptData } from '@/application/collections/';
-import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
-import { Script } from '@/domain/Script';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
-import type { IScriptCode } from '@/domain/IScriptCode';
-import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
+import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
+import { CollectionScript } from '@/domain/Executables/Script/CollectionScript';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
+import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import type { ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
-import { createScriptCode } from '@/domain/ScriptCodeFactory';
-import type { IScript } from '@/domain/IScript';
+import type { ScriptCodeFactory } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
+import { createScriptCode } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
+import type { Script } from '@/domain/Executables/Script/Script';
+import { createEnumParser, type IEnumParser } from '@/application/Common/Enum';
 import { parseDocs, type DocsParser } from '../DocumentationParser';
-import { createEnumParser, type IEnumParser } from '../../Common/Enum';
-import { NodeDataType } from '../NodeValidation/NodeDataType';
-import { createNodeDataValidator, type NodeDataValidator, type NodeDataValidatorFactory } from '../NodeValidation/NodeDataValidator';
+import { ExecutableType } from '../Validation/ExecutableType';
+import { createExecutableDataValidator, type ExecutableValidator, type ExecutableValidatorFactory } from '../Validation/ExecutableValidator';
 import { CodeValidator } from './Validation/CodeValidator';
 import { NoDuplicatedLines } from './Validation/Rules/NoDuplicatedLines';
-import type { ICategoryCollectionParseContext } from './ICategoryCollectionParseContext';
+import type { CategoryCollectionSpecificUtilities } from '../CategoryCollectionSpecificUtilities';
 
 export interface ScriptParser {
   (
     data: ScriptData,
-    context: ICategoryCollectionParseContext,
-    utilities?: ScriptParserUtilities,
-  ): IScript;
+    collectionUtilities: CategoryCollectionSpecificUtilities,
+    scriptUtilities?: ScriptParserUtilities,
+  ): Script;
 }
 
 export const parseScript: ScriptParser = (
   data,
-  context,
+  collectionUtilities,
   utilities = DefaultScriptParserUtilities,
 ) => {
   const validator = utilities.createValidator({
-    type: NodeDataType.Script,
-    selfNode: data,
+    type: ExecutableType.Script,
+    self: data,
   });
   validateScript(data, validator);
   try {
     const script = utilities.createScript({
       name: data.name,
-      code: parseCode(data, context, utilities.codeValidator, utilities.createCode),
+      code: parseCode(data, collectionUtilities, utilities.codeValidator, utilities.createCode),
       docs: utilities.parseDocs(data),
       level: parseLevel(data.recommend, utilities.levelParser),
     });
@@ -63,21 +63,21 @@ function parseLevel(
 
 function parseCode(
   script: ScriptData,
-  context: ICategoryCollectionParseContext,
+  collectionUtilities: CategoryCollectionSpecificUtilities,
   codeValidator: ICodeValidator,
   createCode: ScriptCodeFactory,
-): IScriptCode {
-  if (context.compiler.canCompile(script)) {
-    return context.compiler.compile(script);
+): ScriptCode {
+  if (collectionUtilities.compiler.canCompile(script)) {
+    return collectionUtilities.compiler.compile(script);
   }
   const codeScript = script as CodeScriptData; // Must be inline code if it cannot be compiled
   const code = createCode(codeScript.code, codeScript.revertCode);
-  validateHardcodedCodeWithoutCalls(code, codeValidator, context.syntax);
+  validateHardcodedCodeWithoutCalls(code, codeValidator, collectionUtilities.syntax);
   return code;
 }
 
 function validateHardcodedCodeWithoutCalls(
-  scriptCode: IScriptCode,
+  scriptCode: ScriptCode,
   validator: ICodeValidator,
   syntax: ILanguageSyntax,
 ) {
@@ -93,7 +93,7 @@ function validateHardcodedCodeWithoutCalls(
 
 function validateScript(
   script: ScriptData,
-  validator: NodeDataValidator,
+  validator: ExecutableValidator,
 ): asserts script is NonNullable<ScriptData> {
   validator.assertDefined(script);
   validator.assertValidName(script.name);
@@ -116,17 +116,17 @@ interface ScriptParserUtilities {
   readonly createScript: ScriptFactory;
   readonly codeValidator: ICodeValidator;
   readonly wrapError: ErrorWithContextWrapper;
-  readonly createValidator: NodeDataValidatorFactory;
+  readonly createValidator: ExecutableValidatorFactory;
   readonly createCode: ScriptCodeFactory;
   readonly parseDocs: DocsParser;
 }
 
 export type ScriptFactory = (
-  ...parameters: ConstructorParameters<typeof Script>
-) => IScript;
+  ...parameters: ConstructorParameters<typeof CollectionScript>
+) => Script;
 
 const createScript: ScriptFactory = (...parameters) => {
-  return new Script(...parameters);
+  return new CollectionScript(...parameters);
 };
 
 const DefaultScriptParserUtilities: ScriptParserUtilities = {
@@ -134,7 +134,7 @@ const DefaultScriptParserUtilities: ScriptParserUtilities = {
   createScript,
   codeValidator: CodeValidator.instance,
   wrapError: wrapErrorWithAdditionalContext,
-  createValidator: createNodeDataValidator,
+  createValidator: createExecutableDataValidator,
   createCode: createScriptCode,
   parseDocs,
 };
diff --git a/src/application/Parser/Script/Validation/CodeValidator.ts b/src/application/Parser/Executable/Script/Validation/CodeValidator.ts
similarity index 100%
rename from src/application/Parser/Script/Validation/CodeValidator.ts
rename to src/application/Parser/Executable/Script/Validation/CodeValidator.ts
diff --git a/src/application/Parser/Script/Validation/ICodeLine.ts b/src/application/Parser/Executable/Script/Validation/ICodeLine.ts
similarity index 100%
rename from src/application/Parser/Script/Validation/ICodeLine.ts
rename to src/application/Parser/Executable/Script/Validation/ICodeLine.ts
diff --git a/src/application/Parser/Script/Validation/ICodeValidationRule.ts b/src/application/Parser/Executable/Script/Validation/ICodeValidationRule.ts
similarity index 100%
rename from src/application/Parser/Script/Validation/ICodeValidationRule.ts
rename to src/application/Parser/Executable/Script/Validation/ICodeValidationRule.ts
diff --git a/src/application/Parser/Script/Validation/ICodeValidator.ts b/src/application/Parser/Executable/Script/Validation/ICodeValidator.ts
similarity index 100%
rename from src/application/Parser/Script/Validation/ICodeValidator.ts
rename to src/application/Parser/Executable/Script/Validation/ICodeValidator.ts
diff --git a/src/application/Parser/Script/Validation/Rules/NoDuplicatedLines.ts b/src/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines.ts
similarity index 93%
rename from src/application/Parser/Script/Validation/Rules/NoDuplicatedLines.ts
rename to src/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines.ts
index 2fa9b06e..f61845f6 100644
--- a/src/application/Parser/Script/Validation/Rules/NoDuplicatedLines.ts
+++ b/src/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines.ts
@@ -1,4 +1,4 @@
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 import type { ICodeLine } from '../ICodeLine';
 import type { ICodeValidationRule, IInvalidCodeLine } from '../ICodeValidationRule';
 
diff --git a/src/application/Parser/Script/Validation/Rules/NoEmptyLines.ts b/src/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines.ts
similarity index 100%
rename from src/application/Parser/Script/Validation/Rules/NoEmptyLines.ts
rename to src/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines.ts
diff --git a/src/application/Parser/Script/Validation/Syntax/BatchFileSyntax.ts b/src/application/Parser/Executable/Script/Validation/Syntax/BatchFileSyntax.ts
similarity index 73%
rename from src/application/Parser/Script/Validation/Syntax/BatchFileSyntax.ts
rename to src/application/Parser/Executable/Script/Validation/Syntax/BatchFileSyntax.ts
index f7913efc..8df1765f 100644
--- a/src/application/Parser/Script/Validation/Syntax/BatchFileSyntax.ts
+++ b/src/application/Parser/Executable/Script/Validation/Syntax/BatchFileSyntax.ts
@@ -1,4 +1,4 @@
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 
 const BatchFileCommonCodeParts = ['(', ')', 'else', '||'];
 const PowerShellCommonCodeParts = ['{', '}'];
diff --git a/src/application/Parser/Script/Validation/Syntax/ILanguageSyntax.ts b/src/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax.ts
similarity index 100%
rename from src/application/Parser/Script/Validation/Syntax/ILanguageSyntax.ts
rename to src/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax.ts
diff --git a/src/application/Parser/Script/Validation/Syntax/ISyntaxFactory.ts b/src/application/Parser/Executable/Script/Validation/Syntax/ISyntaxFactory.ts
similarity index 100%
rename from src/application/Parser/Script/Validation/Syntax/ISyntaxFactory.ts
rename to src/application/Parser/Executable/Script/Validation/Syntax/ISyntaxFactory.ts
diff --git a/src/application/Parser/Script/Validation/Syntax/ShellScriptSyntax.ts b/src/application/Parser/Executable/Script/Validation/Syntax/ShellScriptSyntax.ts
similarity index 61%
rename from src/application/Parser/Script/Validation/Syntax/ShellScriptSyntax.ts
rename to src/application/Parser/Executable/Script/Validation/Syntax/ShellScriptSyntax.ts
index 892ffb31..9b703423 100644
--- a/src/application/Parser/Script/Validation/Syntax/ShellScriptSyntax.ts
+++ b/src/application/Parser/Executable/Script/Validation/Syntax/ShellScriptSyntax.ts
@@ -1,4 +1,4 @@
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 
 export class ShellScriptSyntax implements ILanguageSyntax {
   public readonly commentDelimiters = ['#'];
diff --git a/src/application/Parser/Script/Validation/Syntax/SyntaxFactory.ts b/src/application/Parser/Executable/Script/Validation/Syntax/SyntaxFactory.ts
similarity index 85%
rename from src/application/Parser/Script/Validation/Syntax/SyntaxFactory.ts
rename to src/application/Parser/Executable/Script/Validation/Syntax/SyntaxFactory.ts
index 5d981251..31d9f02e 100644
--- a/src/application/Parser/Script/Validation/Syntax/SyntaxFactory.ts
+++ b/src/application/Parser/Executable/Script/Validation/Syntax/SyntaxFactory.ts
@@ -1,6 +1,6 @@
 import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
 import { ScriptingLanguageFactory } from '@/application/Common/ScriptingLanguage/ScriptingLanguageFactory';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 import { BatchFileSyntax } from './BatchFileSyntax';
 import { ShellScriptSyntax } from './ShellScriptSyntax';
 import type { ISyntaxFactory } from './ISyntaxFactory';
diff --git a/src/application/Parser/Executable/Validation/ExecutableErrorContext.ts b/src/application/Parser/Executable/Validation/ExecutableErrorContext.ts
new file mode 100644
index 00000000..d6122e52
--- /dev/null
+++ b/src/application/Parser/Executable/Validation/ExecutableErrorContext.ts
@@ -0,0 +1,24 @@
+import type { CategoryData, ScriptData, ExecutableData } from '@/application/collections/';
+import { ExecutableType } from './ExecutableType';
+
+export type ExecutableErrorContext = {
+  readonly parentCategory?: CategoryData;
+} & (CategoryErrorContext | ScriptErrorContext | UnknownExecutableErrorContext);
+
+export type CategoryErrorContext = {
+  readonly type: ExecutableType.Category;
+  readonly self: CategoryData;
+  readonly parentCategory?: CategoryData;
+};
+
+export type ScriptErrorContext = {
+  readonly type: ExecutableType.Script;
+  readonly self: ScriptData;
+  readonly parentCategory?: CategoryData;
+};
+
+export type UnknownExecutableErrorContext = {
+  readonly type?: undefined;
+  readonly self: ExecutableData;
+  readonly parentCategory?: CategoryData;
+};
diff --git a/src/application/Parser/Executable/Validation/ExecutableErrorContextMessage.ts b/src/application/Parser/Executable/Validation/ExecutableErrorContextMessage.ts
new file mode 100644
index 00000000..70234e6b
--- /dev/null
+++ b/src/application/Parser/Executable/Validation/ExecutableErrorContextMessage.ts
@@ -0,0 +1,35 @@
+import type { ExecutableData } from '@/application/collections/';
+import { ExecutableType } from './ExecutableType';
+import type { ExecutableErrorContext } from './ExecutableErrorContext';
+
+export interface ExecutableContextErrorMessageCreator {
+  (
+    errorMessage: string,
+    context: ExecutableErrorContext,
+  ): string;
+}
+
+export const createExecutableContextErrorMessage: ExecutableContextErrorMessageCreator = (
+  errorMessage,
+  context,
+) => {
+  let message = '';
+  if (context.type !== undefined) {
+    message += `${ExecutableType[context.type]}: `;
+  }
+  message += errorMessage;
+  message += `\n${getErrorContextDetails(context)}`;
+  return message;
+};
+
+function getErrorContextDetails(context: ExecutableErrorContext): string {
+  let output = `Self: ${printExecutable(context.self)}`;
+  if (context.parentCategory) {
+    output += `\nParent: ${printExecutable(context.parentCategory)}`;
+  }
+  return output;
+}
+
+function printExecutable(executable: ExecutableData): string {
+  return JSON.stringify(executable, undefined, 2);
+}
diff --git a/src/application/Parser/Executable/Validation/ExecutableType.ts b/src/application/Parser/Executable/Validation/ExecutableType.ts
new file mode 100644
index 00000000..17526dac
--- /dev/null
+++ b/src/application/Parser/Executable/Validation/ExecutableType.ts
@@ -0,0 +1,4 @@
+export enum ExecutableType {
+  Script,
+  Category,
+}
diff --git a/src/application/Parser/NodeValidation/NodeDataValidator.ts b/src/application/Parser/Executable/Validation/ExecutableValidator.ts
similarity index 52%
rename from src/application/Parser/NodeValidation/NodeDataValidator.ts
rename to src/application/Parser/Executable/Validation/ExecutableValidator.ts
index 757a3e21..c69f8afc 100644
--- a/src/application/Parser/NodeValidation/NodeDataValidator.ts
+++ b/src/application/Parser/Executable/Validation/ExecutableValidator.ts
@@ -1,17 +1,17 @@
 import { isString } from '@/TypeHelpers';
-import { type NodeDataErrorContext } from './NodeDataErrorContext';
-import { createNodeContextErrorMessage, type NodeContextErrorMessageCreator } from './NodeDataErrorContextMessage';
-import type { NodeData } from './NodeData';
+import type { ExecutableData } from '@/application/collections/';
+import { type ExecutableErrorContext } from './ExecutableErrorContext';
+import { createExecutableContextErrorMessage, type ExecutableContextErrorMessageCreator } from './ExecutableErrorContextMessage';
 
-export interface NodeDataValidatorFactory {
-  (context: NodeDataErrorContext): NodeDataValidator;
+export interface ExecutableValidatorFactory {
+  (context: ExecutableErrorContext): ExecutableValidator;
 }
 
-export interface NodeDataValidator {
+export interface ExecutableValidator {
   assertValidName(nameValue: string): void;
   assertDefined(
-    node: NodeData | undefined,
-  ): asserts node is NonNullable<NodeData> & void;
+    data: ExecutableData | undefined,
+  ): asserts data is NonNullable<ExecutableData> & void;
   assert(
     validationPredicate: () => boolean,
     errorMessage: string,
@@ -19,14 +19,14 @@ export interface NodeDataValidator {
   createContextualErrorMessage(errorMessage: string): string;
 }
 
-export const createNodeDataValidator
-: NodeDataValidatorFactory = (context) => new ContextualNodeDataValidator(context);
+export const createExecutableDataValidator
+: ExecutableValidatorFactory = (context) => new ContextualExecutableValidator(context);
 
-export class ContextualNodeDataValidator implements NodeDataValidator {
+export class ContextualExecutableValidator implements ExecutableValidator {
   constructor(
-    private readonly context: NodeDataErrorContext,
+    private readonly context: ExecutableErrorContext,
     private readonly createErrorMessage
-    : NodeContextErrorMessageCreator = createNodeContextErrorMessage,
+    : ExecutableContextErrorMessageCreator = createExecutableContextErrorMessage,
   ) {
 
   }
@@ -40,11 +40,11 @@ export class ContextualNodeDataValidator implements NodeDataValidator {
   }
 
   public assertDefined(
-    node: NodeData,
-  ): asserts node is NonNullable<NodeData> {
+    data: ExecutableData,
+  ): asserts data is NonNullable<ExecutableData> {
     this.assert(
-      () => node !== undefined && node !== null && Object.keys(node).length > 0,
-      'missing node data',
+      () => data !== undefined && data !== null && Object.keys(data).length > 0,
+      'missing executable data',
     );
   }
 
diff --git a/src/application/Parser/NodeValidation/NodeData.ts b/src/application/Parser/NodeValidation/NodeData.ts
deleted file mode 100644
index 1b12dc69..00000000
--- a/src/application/Parser/NodeValidation/NodeData.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import type { ScriptData, CategoryData } from '@/application/collections/';
-
-export type NodeData = CategoryData | ScriptData;
diff --git a/src/application/Parser/NodeValidation/NodeDataErrorContext.ts b/src/application/Parser/NodeValidation/NodeDataErrorContext.ts
deleted file mode 100644
index f5e6fe85..00000000
--- a/src/application/Parser/NodeValidation/NodeDataErrorContext.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import type { CategoryData, ScriptData } from '@/application/collections/';
-import { NodeDataType } from './NodeDataType';
-import type { NodeData } from './NodeData';
-
-export type NodeDataErrorContext = {
-  readonly parentNode?: CategoryData;
-} & (CategoryNodeErrorContext | ScriptNodeErrorContext | UnknownNodeErrorContext);
-
-export type CategoryNodeErrorContext = {
-  readonly type: NodeDataType.Category;
-  readonly selfNode: CategoryData;
-  readonly parentNode?: CategoryData;
-};
-
-export type ScriptNodeErrorContext = {
-  readonly type: NodeDataType.Script;
-  readonly selfNode: ScriptData;
-  readonly parentNode?: CategoryData;
-};
-
-export type UnknownNodeErrorContext = {
-  readonly type?: undefined;
-  readonly selfNode: NodeData;
-  readonly parentNode?: CategoryData;
-};
diff --git a/src/application/Parser/NodeValidation/NodeDataErrorContextMessage.ts b/src/application/Parser/NodeValidation/NodeDataErrorContextMessage.ts
deleted file mode 100644
index 70956697..00000000
--- a/src/application/Parser/NodeValidation/NodeDataErrorContextMessage.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { NodeDataType } from './NodeDataType';
-import type { NodeDataErrorContext } from './NodeDataErrorContext';
-import type { NodeData } from './NodeData';
-
-export interface NodeContextErrorMessageCreator {
-  (
-    errorMessage: string,
-    context: NodeDataErrorContext,
-  ): string;
-}
-
-export const createNodeContextErrorMessage: NodeContextErrorMessageCreator = (
-  errorMessage,
-  context,
-) => {
-  let message = '';
-  if (context.type !== undefined) {
-    message += `${NodeDataType[context.type]}: `;
-  }
-  message += errorMessage;
-  message += `\n${getErrorContextDetails(context)}`;
-  return message;
-};
-
-function getErrorContextDetails(context: NodeDataErrorContext): string {
-  let output = `Self: ${printNodeDataAsJson(context.selfNode)}`;
-  if (context.parentNode) {
-    output += `\nParent: ${printNodeDataAsJson(context.parentNode)}`;
-  }
-  return output;
-}
-
-function printNodeDataAsJson(node: NodeData): string {
-  return JSON.stringify(node, undefined, 2);
-}
diff --git a/src/application/Parser/NodeValidation/NodeDataType.ts b/src/application/Parser/NodeValidation/NodeDataType.ts
deleted file mode 100644
index cc4dac96..00000000
--- a/src/application/Parser/NodeValidation/NodeDataType.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export enum NodeDataType {
-  Script,
-  Category,
-}
diff --git a/src/application/Parser/Script/CategoryCollectionParseContext.ts b/src/application/Parser/Script/CategoryCollectionParseContext.ts
deleted file mode 100644
index a3d4c043..00000000
--- a/src/application/Parser/Script/CategoryCollectionParseContext.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import type { FunctionData } from '@/application/collections/';
-import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
-import { ScriptCompiler } from './Compiler/ScriptCompiler';
-import { SyntaxFactory } from './Validation/Syntax/SyntaxFactory';
-import type { ILanguageSyntax } from './Validation/Syntax/ILanguageSyntax';
-import type { IScriptCompiler } from './Compiler/IScriptCompiler';
-import type { ICategoryCollectionParseContext } from './ICategoryCollectionParseContext';
-import type { ISyntaxFactory } from './Validation/Syntax/ISyntaxFactory';
-
-export class CategoryCollectionParseContext implements ICategoryCollectionParseContext {
-  public readonly compiler: IScriptCompiler;
-
-  public readonly syntax: ILanguageSyntax;
-
-  constructor(
-    functionsData: ReadonlyArray<FunctionData> | undefined,
-    scripting: IScriptingDefinition,
-    syntaxFactory: ISyntaxFactory = new SyntaxFactory(),
-  ) {
-    this.syntax = syntaxFactory.create(scripting.language);
-    this.compiler = new ScriptCompiler(functionsData ?? [], this.syntax);
-  }
-}
diff --git a/src/application/Parser/Script/ICategoryCollectionParseContext.ts b/src/application/Parser/Script/ICategoryCollectionParseContext.ts
deleted file mode 100644
index d841ce76..00000000
--- a/src/application/Parser/Script/ICategoryCollectionParseContext.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import type { IScriptCompiler } from './Compiler/IScriptCompiler';
-import type { ILanguageSyntax } from './Validation/Syntax/ILanguageSyntax';
-
-export interface ICategoryCollectionParseContext {
-  readonly compiler: IScriptCompiler;
-  readonly syntax: ILanguageSyntax;
-}
diff --git a/src/application/Parser/ScriptingDefinition/CodeSubstituter.ts b/src/application/Parser/ScriptingDefinition/CodeSubstituter.ts
index fc7aa24f..52b3257b 100644
--- a/src/application/Parser/ScriptingDefinition/CodeSubstituter.ts
+++ b/src/application/Parser/ScriptingDefinition/CodeSubstituter.ts
@@ -1,11 +1,11 @@
-import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
-import { ParameterSubstitutionParser } from '@/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser';
-import { CompositeExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser';
-import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
+import { ParameterSubstitutionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser';
+import { CompositeExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/CompositeExpressionParser';
+import { ExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler';
 import type { ProjectDetails } from '@/domain/Project/ProjectDetails';
-import { FunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
-import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
-import type { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
+import { FunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
+import { FunctionCallArgument } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
+import type { IExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser';
 import type { ICodeSubstituter } from './ICodeSubstituter';
 
 export class CodeSubstituter implements ICodeSubstituter {
diff --git a/src/application/collections/collection.yaml.d.ts b/src/application/collections/collection.yaml.d.ts
index b429420b..952b067f 100644
--- a/src/application/collections/collection.yaml.d.ts
+++ b/src/application/collections/collection.yaml.d.ts
@@ -1,4 +1,8 @@
 declare module '@/application/collections/*' {
+  export interface ExecutableDefinition extends DocumentableData {
+
+  }
+
   export interface CollectionData {
     readonly os: string;
     readonly scripting: ScriptingDefinitionData;
@@ -6,12 +10,12 @@ declare module '@/application/collections/*' {
     readonly functions?: ReadonlyArray<FunctionData>;
   }
 
-  export interface CategoryData extends DocumentableData {
-    readonly children: ReadonlyArray<CategoryOrScriptData>;
+  export interface CategoryData extends ExecutableDefinition {
+    readonly children: ReadonlyArray<ExecutableData>;
     readonly category: string;
   }
 
-  export type CategoryOrScriptData = CategoryData | ScriptData;
+  export type ExecutableData = CategoryData | ScriptData;
   export type DocumentationData = ReadonlyArray<string> | string | undefined;
 
   export interface DocumentableData {
@@ -56,7 +60,7 @@ declare module '@/application/collections/*' {
 
   export type FunctionCallsData = readonly FunctionCallData[] | FunctionCallData | undefined;
 
-  export type ScriptDefinition = DocumentableData & {
+  export type ScriptDefinition = ExecutableDefinition & {
     readonly name: string;
     readonly recommend?: string;
   };
diff --git a/src/domain/CategoryCollection.ts b/src/domain/CategoryCollection.ts
index ff50d139..6ce9580d 100644
--- a/src/domain/CategoryCollection.ts
+++ b/src/domain/CategoryCollection.ts
@@ -1,9 +1,9 @@
 import { getEnumValues, assertInRange } from '@/application/Common/Enum';
-import { RecommendationLevel } from './RecommendationLevel';
+import { RecommendationLevel } from './Executables/Script/RecommendationLevel';
 import { OperatingSystem } from './OperatingSystem';
 import type { IEntity } from '../infrastructure/Entity/IEntity';
-import type { ICategory } from './ICategory';
-import type { IScript } from './IScript';
+import type { Category } from './Executables/Category/Category';
+import type { Script } from './Executables/Script/Script';
 import type { IScriptingDefinition } from './IScriptingDefinition';
 import type { ICategoryCollection } from './ICategoryCollection';
 
@@ -16,7 +16,7 @@ export class CategoryCollection implements ICategoryCollection {
 
   constructor(
     public readonly os: OperatingSystem,
-    public readonly actions: ReadonlyArray<ICategory>,
+    public readonly actions: ReadonlyArray<Category>,
     public readonly scripting: IScriptingDefinition,
   ) {
     this.queryable = makeQueryable(actions);
@@ -26,7 +26,7 @@ export class CategoryCollection implements ICategoryCollection {
     ensureNoDuplicates(this.queryable.allScripts);
   }
 
-  public getCategory(categoryId: number): ICategory {
+  public getCategory(categoryId: number): Category {
     const category = this.queryable.allCategories.find((c) => c.id === categoryId);
     if (!category) {
       throw new Error(`Missing category with ID: "${categoryId}"`);
@@ -34,13 +34,13 @@ export class CategoryCollection implements ICategoryCollection {
     return category;
   }
 
-  public getScriptsByLevel(level: RecommendationLevel): readonly IScript[] {
+  public getScriptsByLevel(level: RecommendationLevel): readonly Script[] {
     assertInRange(level, RecommendationLevel);
     const scripts = this.queryable.scriptsByLevel.get(level);
     return scripts ?? [];
   }
 
-  public getScript(scriptId: string): IScript {
+  public getScript(scriptId: string): Script {
     const script = this.queryable.allScripts.find((s) => s.id === scriptId);
     if (!script) {
       throw new Error(`missing script: ${scriptId}`);
@@ -48,11 +48,11 @@ export class CategoryCollection implements ICategoryCollection {
     return script;
   }
 
-  public getAllScripts(): IScript[] {
+  public getAllScripts(): Script[] {
     return this.queryable.allScripts;
   }
 
-  public getAllCategories(): ICategory[] {
+  public getAllCategories(): Category[] {
     return this.queryable.allCategories;
   }
 }
@@ -73,9 +73,9 @@ function ensureNoDuplicates<TKey>(entities: ReadonlyArray<IEntity<TKey>>) {
 }
 
 interface IQueryableCollection {
-  allCategories: ICategory[];
-  allScripts: IScript[];
-  scriptsByLevel: Map<RecommendationLevel, readonly IScript[]>;
+  allCategories: Category[];
+  allScripts: Script[];
+  scriptsByLevel: Map<RecommendationLevel, readonly Script[]>;
 }
 
 function ensureValid(application: IQueryableCollection) {
@@ -83,13 +83,13 @@ function ensureValid(application: IQueryableCollection) {
   ensureValidScripts(application.allScripts);
 }
 
-function ensureValidCategories(allCategories: readonly ICategory[]) {
+function ensureValidCategories(allCategories: readonly Category[]) {
   if (!allCategories.length) {
     throw new Error('must consist of at least one category');
   }
 }
 
-function ensureValidScripts(allScripts: readonly IScript[]) {
+function ensureValidScripts(allScripts: readonly Script[]) {
   if (!allScripts.length) {
     throw new Error('must consist of at least one script');
   }
@@ -102,8 +102,8 @@ function ensureValidScripts(allScripts: readonly IScript[]) {
 }
 
 function flattenApplication(
-  categories: ReadonlyArray<ICategory>,
-): [ICategory[], IScript[]] {
+  categories: ReadonlyArray<Category>,
+): [Category[], Script[]] {
   const [subCategories, subScripts] = (categories || [])
     // Parse children
     .map((category) => flattenApplication(category.subCategories))
@@ -113,7 +113,7 @@ function flattenApplication(
         [...previousCategories, ...currentCategories],
         [...previousScripts, ...currentScripts],
       ];
-    }, [new Array<ICategory>(), new Array<IScript>()]);
+    }, [new Array<Category>(), new Array<Script>()]);
   return [
     [
       ...(categories || []),
@@ -127,7 +127,7 @@ function flattenApplication(
 }
 
 function makeQueryable(
-  actions: ReadonlyArray<ICategory>,
+  actions: ReadonlyArray<Category>,
 ): IQueryableCollection {
   const flattened = flattenApplication(actions);
   return {
@@ -138,8 +138,8 @@ function makeQueryable(
 }
 
 function groupByLevel(
-  allScripts: readonly IScript[],
-): Map<RecommendationLevel, readonly IScript[]> {
+  allScripts: readonly Script[],
+): Map<RecommendationLevel, readonly Script[]> {
   return getEnumValues(RecommendationLevel)
     .map((level) => ({
       level,
@@ -150,5 +150,5 @@ function groupByLevel(
     .reduce((map, group) => {
       map.set(group.level, group.scripts);
       return map;
-    }, new Map<RecommendationLevel, readonly IScript[]>());
+    }, new Map<RecommendationLevel, readonly Script[]>());
 }
diff --git a/src/domain/Executables/Category/Category.ts b/src/domain/Executables/Category/Category.ts
new file mode 100644
index 00000000..ff0bd93f
--- /dev/null
+++ b/src/domain/Executables/Category/Category.ts
@@ -0,0 +1,11 @@
+import type { Script } from '../Script/Script';
+import type { Executable } from '../Executable';
+
+export interface Category extends Executable<number> {
+  readonly id: number;
+  readonly name: string;
+  readonly subCategories: ReadonlyArray<Category>;
+  readonly scripts: ReadonlyArray<Script>;
+  includes(script: Script): boolean;
+  getAllScriptsRecursively(): ReadonlyArray<Script>;
+}
diff --git a/src/domain/Category.ts b/src/domain/Executables/Category/CollectionCategory.ts
similarity index 62%
rename from src/domain/Category.ts
rename to src/domain/Executables/Category/CollectionCategory.ts
index b325b20d..5d51d0a1 100644
--- a/src/domain/Category.ts
+++ b/src/domain/Executables/Category/CollectionCategory.ts
@@ -1,17 +1,17 @@
-import { BaseEntity } from '../infrastructure/Entity/BaseEntity';
-import type { ICategory } from './ICategory';
-import type { IScript } from './IScript';
+import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
+import type { Category } from './Category';
+import type { Script } from '../Script/Script';
 
-export class Category extends BaseEntity<number> implements ICategory {
-  private allSubScripts?: ReadonlyArray<IScript> = undefined;
+export class CollectionCategory extends BaseEntity<number> implements Category {
+  private allSubScripts?: ReadonlyArray<Script> = undefined;
 
   public readonly name: string;
 
   public readonly docs: ReadonlyArray<string>;
 
-  public readonly subCategories: ReadonlyArray<ICategory>;
+  public readonly subCategories: ReadonlyArray<Category>;
 
-  public readonly scripts: ReadonlyArray<IScript>;
+  public readonly scripts: ReadonlyArray<Script>;
 
   constructor(parameters: CategoryInitParameters) {
     super(parameters.id);
@@ -22,11 +22,11 @@ export class Category extends BaseEntity<number> implements ICategory {
     this.scripts = parameters.scripts;
   }
 
-  public includes(script: IScript): boolean {
+  public includes(script: Script): boolean {
     return this.getAllScriptsRecursively().some((childScript) => childScript.id === script.id);
   }
 
-  public getAllScriptsRecursively(): readonly IScript[] {
+  public getAllScriptsRecursively(): readonly Script[] {
     if (!this.allSubScripts) {
       this.allSubScripts = parseScriptsRecursively(this);
     }
@@ -38,11 +38,11 @@ export interface CategoryInitParameters {
   readonly id: number;
   readonly name: string;
   readonly docs: ReadonlyArray<string>;
-  readonly subcategories: ReadonlyArray<ICategory>;
-  readonly scripts: ReadonlyArray<IScript>;
+  readonly subcategories: ReadonlyArray<Category>;
+  readonly scripts: ReadonlyArray<Script>;
 }
 
-function parseScriptsRecursively(category: ICategory): ReadonlyArray<IScript> {
+function parseScriptsRecursively(category: Category): ReadonlyArray<Script> {
   return [
     ...category.scripts,
     ...category.subCategories.flatMap((c) => c.getAllScriptsRecursively()),
diff --git a/src/domain/IDocumentable.ts b/src/domain/Executables/Documentable.ts
similarity index 56%
rename from src/domain/IDocumentable.ts
rename to src/domain/Executables/Documentable.ts
index 76c253cf..31d3617f 100644
--- a/src/domain/IDocumentable.ts
+++ b/src/domain/Executables/Documentable.ts
@@ -1,3 +1,3 @@
-export interface IDocumentable {
+export interface Documentable {
   readonly docs: ReadonlyArray<string>;
 }
diff --git a/src/domain/Executables/Executable.ts b/src/domain/Executables/Executable.ts
new file mode 100644
index 00000000..39e6d908
--- /dev/null
+++ b/src/domain/Executables/Executable.ts
@@ -0,0 +1,6 @@
+import type { IEntity } from '@/infrastructure/Entity/IEntity';
+import type { Documentable } from './Documentable';
+
+export interface Executable<TExecutableKey>
+  extends Documentable, IEntity<TExecutableKey> {
+}
diff --git a/src/domain/ScriptCode.ts b/src/domain/Executables/Script/Code/DistinctReversibleScriptCode.ts
similarity index 84%
rename from src/domain/ScriptCode.ts
rename to src/domain/Executables/Script/Code/DistinctReversibleScriptCode.ts
index 08924eb8..e1edc960 100644
--- a/src/domain/ScriptCode.ts
+++ b/src/domain/Executables/Script/Code/DistinctReversibleScriptCode.ts
@@ -1,6 +1,6 @@
-import type { IScriptCode } from './IScriptCode';
+import type { ScriptCode } from './ScriptCode';
 
-export class ScriptCode implements IScriptCode {
+export class DistinctReversibleScriptCode implements ScriptCode {
   constructor(
     public readonly execute: string,
     public readonly revert: string | undefined,
diff --git a/src/domain/IScriptCode.ts b/src/domain/Executables/Script/Code/ScriptCode.ts
similarity index 65%
rename from src/domain/IScriptCode.ts
rename to src/domain/Executables/Script/Code/ScriptCode.ts
index c2c8900c..47249ba2 100644
--- a/src/domain/IScriptCode.ts
+++ b/src/domain/Executables/Script/Code/ScriptCode.ts
@@ -1,4 +1,4 @@
-export interface IScriptCode {
+export interface ScriptCode {
   readonly execute: string;
   readonly revert?: string;
 }
diff --git a/src/domain/Executables/Script/Code/ScriptCodeFactory.ts b/src/domain/Executables/Script/Code/ScriptCodeFactory.ts
new file mode 100644
index 00000000..1dbfa738
--- /dev/null
+++ b/src/domain/Executables/Script/Code/ScriptCodeFactory.ts
@@ -0,0 +1,12 @@
+import { DistinctReversibleScriptCode } from './DistinctReversibleScriptCode';
+import type { ScriptCode } from './ScriptCode';
+
+export interface ScriptCodeFactory {
+  (
+    ...args: ConstructorParameters<typeof DistinctReversibleScriptCode>
+  ): ScriptCode;
+}
+
+export const createScriptCode: ScriptCodeFactory = (
+  ...args
+) => new DistinctReversibleScriptCode(...args);
diff --git a/src/domain/Script.ts b/src/domain/Executables/Script/CollectionScript.ts
similarity index 79%
rename from src/domain/Script.ts
rename to src/domain/Executables/Script/CollectionScript.ts
index 7440aa4c..dd9f34fc 100644
--- a/src/domain/Script.ts
+++ b/src/domain/Executables/Script/CollectionScript.ts
@@ -1,12 +1,12 @@
 import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
 import { RecommendationLevel } from './RecommendationLevel';
-import type { IScript } from './IScript';
-import type { IScriptCode } from './IScriptCode';
+import type { Script } from './Script';
+import type { ScriptCode } from './Code/ScriptCode';
 
-export class Script extends BaseEntity<string> implements IScript {
+export class CollectionScript extends BaseEntity<string> implements Script {
   public readonly name: string;
 
-  public readonly code: IScriptCode;
+  public readonly code: ScriptCode;
 
   public readonly docs: ReadonlyArray<string>;
 
@@ -28,7 +28,7 @@ export class Script extends BaseEntity<string> implements IScript {
 
 export interface ScriptInitParameters {
   readonly name: string;
-  readonly code: IScriptCode;
+  readonly code: ScriptCode;
   readonly docs: ReadonlyArray<string>;
   readonly level?: RecommendationLevel;
 }
diff --git a/src/domain/RecommendationLevel.ts b/src/domain/Executables/Script/RecommendationLevel.ts
similarity index 100%
rename from src/domain/RecommendationLevel.ts
rename to src/domain/Executables/Script/RecommendationLevel.ts
diff --git a/src/domain/Executables/Script/Script.ts b/src/domain/Executables/Script/Script.ts
new file mode 100644
index 00000000..705264d8
--- /dev/null
+++ b/src/domain/Executables/Script/Script.ts
@@ -0,0 +1,11 @@
+import { RecommendationLevel } from './RecommendationLevel';
+import type { Executable } from '../Executable';
+import type { Documentable } from '../Documentable';
+import type { ScriptCode } from './Code/ScriptCode';
+
+export interface Script extends Executable<string>, Documentable {
+  readonly name: string;
+  readonly level?: RecommendationLevel;
+  readonly code: ScriptCode;
+  canRevert(): boolean;
+}
diff --git a/src/domain/ICategory.ts b/src/domain/ICategory.ts
deleted file mode 100644
index 4cfefe9d..00000000
--- a/src/domain/ICategory.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import type { IEntity } from '../infrastructure/Entity/IEntity';
-import type { IScript } from './IScript';
-import type { IDocumentable } from './IDocumentable';
-
-export interface ICategory extends IEntity<number>, IDocumentable {
-  readonly id: number;
-  readonly name: string;
-  readonly subCategories: ReadonlyArray<ICategory>;
-  readonly scripts: ReadonlyArray<IScript>;
-  includes(script: IScript): boolean;
-  getAllScriptsRecursively(): ReadonlyArray<IScript>;
-}
-
-export type { IEntity } from '../infrastructure/Entity/IEntity';
-export type { IScript } from './IScript';
diff --git a/src/domain/ICategoryCollection.ts b/src/domain/ICategoryCollection.ts
index dd05ebb8..c7b7d799 100644
--- a/src/domain/ICategoryCollection.ts
+++ b/src/domain/ICategoryCollection.ts
@@ -1,19 +1,19 @@
 import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
 import { OperatingSystem } from '@/domain/OperatingSystem';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
-import type { IScript } from '@/domain/IScript';
-import type { ICategory } from '@/domain/ICategory';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
+import type { Script } from '@/domain/Executables/Script/Script';
+import type { Category } from '@/domain/Executables/Category/Category';
 
 export interface ICategoryCollection {
   readonly scripting: IScriptingDefinition;
   readonly os: OperatingSystem;
   readonly totalScripts: number;
   readonly totalCategories: number;
-  readonly actions: ReadonlyArray<ICategory>;
+  readonly actions: ReadonlyArray<Category>;
 
-  getScriptsByLevel(level: RecommendationLevel): ReadonlyArray<IScript>;
-  getCategory(categoryId: number): ICategory;
-  getScript(scriptId: string): IScript;
-  getAllScripts(): ReadonlyArray<IScript>;
-  getAllCategories(): ReadonlyArray<ICategory>;
+  getScriptsByLevel(level: RecommendationLevel): ReadonlyArray<Script>;
+  getCategory(categoryId: number): Category;
+  getScript(scriptId: string): Script;
+  getAllScripts(): ReadonlyArray<Script>;
+  getAllCategories(): ReadonlyArray<Category>;
 }
diff --git a/src/domain/IScript.ts b/src/domain/IScript.ts
deleted file mode 100644
index 5ee1634c..00000000
--- a/src/domain/IScript.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { RecommendationLevel } from './RecommendationLevel';
-import type { IEntity } from '../infrastructure/Entity/IEntity';
-import type { IDocumentable } from './IDocumentable';
-import type { IScriptCode } from './IScriptCode';
-
-export interface IScript extends IEntity<string>, IDocumentable {
-  readonly name: string;
-  readonly level?: RecommendationLevel;
-  readonly docs: ReadonlyArray<string>;
-  readonly code: IScriptCode;
-  canRevert(): boolean;
-}
diff --git a/src/domain/ScriptCodeFactory.ts b/src/domain/ScriptCodeFactory.ts
deleted file mode 100644
index 303a4df7..00000000
--- a/src/domain/ScriptCodeFactory.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { ScriptCode } from './ScriptCode';
-import type { IScriptCode } from './IScriptCode';
-
-export interface ScriptCodeFactory {
-  (
-    ...args: ConstructorParameters<typeof ScriptCode>
-  ): IScriptCode;
-}
-
-export const createScriptCode: ScriptCodeFactory = (...args) => new ScriptCode(...args);
diff --git a/src/presentation/components/Code/TheCodeArea.vue b/src/presentation/components/Code/TheCodeArea.vue
index 834dd81b..93edd884 100644
--- a/src/presentation/components/Code/TheCodeArea.vue
+++ b/src/presentation/components/Code/TheCodeArea.vue
@@ -18,7 +18,7 @@ import {
 } from 'vue';
 import { injectKey } from '@/presentation/injectionSymbols';
 import type { ICodeChangedEvent } from '@/application/Context/State/Code/Event/ICodeChangedEvent';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
 import type { IReadOnlyCategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
 import { CodeBuilderFactory } from '@/application/Context/State/Code/Generation/CodeBuilderFactory';
@@ -108,7 +108,7 @@ export default defineComponent({
       highlightedRange.value = 0;
     }
 
-    function reactToChanges(event: ICodeChangedEvent, scripts: ReadonlyArray<IScript>) {
+    function reactToChanges(event: ICodeChangedEvent, scripts: ReadonlyArray<Script>) {
       const positions = scripts
         .map((script) => event.getScriptPositionInCode(script));
       const start = Math.min(
diff --git a/src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.ts b/src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.ts
index 21811421..abed6184 100644
--- a/src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.ts
+++ b/src/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.ts
@@ -1,5 +1,5 @@
-import type { IScript } from '@/domain/IScript';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import type { Script } from '@/domain/Executables/Script/Script';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
 import { scrambledEqual } from '@/application/Common/Array';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
 import type { ReadonlyScriptSelection, ScriptSelection } from '@/application/Context/State/Selection/Script/ScriptSelection';
@@ -90,7 +90,7 @@ function selectOnly(
 }
 
 function areAllSelected(
-  expectedScripts: ReadonlyArray<IScript>,
+  expectedScripts: ReadonlyArray<Script>,
   selection: ReadonlyArray<SelectedScript>,
 ): boolean {
   const selectedScriptIds = selection
diff --git a/src/presentation/components/Scripts/Menu/Revert/TheRevertSelector.vue b/src/presentation/components/Scripts/Menu/Revert/TheRevertSelector.vue
index ed3531b8..22414caa 100644
--- a/src/presentation/components/Scripts/Menu/Revert/TheRevertSelector.vue
+++ b/src/presentation/components/Scripts/Menu/Revert/TheRevertSelector.vue
@@ -59,8 +59,8 @@ import {
 } from 'vue';
 import { injectKey } from '@/presentation/injectionSymbols';
 import TooltipWrapper from '@/presentation/components/Shared/TooltipWrapper.vue';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
-import type { IScript } from '@/domain/IScript';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
+import type { Script } from '@/domain/Executables/Script/Script';
 import MenuOptionList from '../MenuOptionList.vue';
 import MenuOptionListItem from '../MenuOptionListItem.vue';
 import RevertStatusDocumentation from './RevertStatusDocumentation.vue';
@@ -83,7 +83,7 @@ export default defineComponent({
       () => getCurrentRevertStatus(currentSelection.value.scripts),
     );
 
-    const selectedScripts = computed<readonly IScript[]>(
+    const selectedScripts = computed<readonly Script[]>(
       () => currentSelection.value.scripts.selectedScripts.map((s) => s.script),
     );
 
diff --git a/src/presentation/components/Scripts/View/Cards/CardSelectionIndicator.vue b/src/presentation/components/Scripts/View/Cards/CardSelectionIndicator.vue
index e29996a0..50295ca2 100644
--- a/src/presentation/components/Scripts/View/Cards/CardSelectionIndicator.vue
+++ b/src/presentation/components/Scripts/View/Cards/CardSelectionIndicator.vue
@@ -15,7 +15,7 @@
 import { defineComponent, computed } from 'vue';
 import AppIcon from '@/presentation/components/Shared/Icon/AppIcon.vue';
 import { injectKey } from '@/presentation/injectionSymbols';
-import type { ICategory } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
 
 export default defineComponent({
@@ -33,7 +33,7 @@ export default defineComponent({
     const { currentSelection } = injectKey((keys) => keys.useUserSelectionState);
     const currentCollection = computed<ICategoryCollection>(() => currentState.value.collection);
 
-    const currentCategory = computed<ICategory>(
+    const currentCategory = computed<Category>(
       () => currentCollection.value.getCategory(props.categoryId),
     );
 
diff --git a/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter.ts b/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter.ts
index e561c6b5..b7354e5d 100644
--- a/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter.ts
+++ b/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter.ts
@@ -1,5 +1,6 @@
-import type { ICategory, IScript } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { type NodeMetadata, NodeType } from '../NodeContent/NodeMetadata';
 
 export function parseAllCategories(collection: ICategoryCollection): NodeMetadata[] {
@@ -15,7 +16,7 @@ export function parseSingleCategory(
   return tree;
 }
 
-export function getScriptNodeId(script: IScript): string {
+export function getScriptNodeId(script: Script): string {
   return script.id;
 }
 
@@ -27,12 +28,12 @@ export function getCategoryId(nodeId: string): number {
   return +nodeId;
 }
 
-export function getCategoryNodeId(category: ICategory): string {
+export function getCategoryNodeId(category: Category): string {
   return `${category.id}`;
 }
 
 function parseCategoryRecursively(
-  parentCategory: ICategory,
+  parentCategory: Category,
 ): NodeMetadata[] {
   return [
     ...createCategoryNodes(parentCategory.subCategories),
@@ -40,19 +41,19 @@ function parseCategoryRecursively(
   ];
 }
 
-function createScriptNodes(scripts: ReadonlyArray<IScript>): NodeMetadata[] {
+function createScriptNodes(scripts: ReadonlyArray<Script>): NodeMetadata[] {
   return (scripts || [])
     .map((script) => convertScriptToNode(script));
 }
 
-function createCategoryNodes(categories: ReadonlyArray<ICategory>): NodeMetadata[] {
+function createCategoryNodes(categories: ReadonlyArray<Category>): NodeMetadata[] {
   return (categories || [])
     .map((category) => ({ category, children: parseCategoryRecursively(category) }))
     .map((data) => convertCategoryToNode(data.category, data.children));
 }
 
 function convertCategoryToNode(
-  category: ICategory,
+  category: Category,
   children: readonly NodeMetadata[],
 ): NodeMetadata {
   return {
@@ -65,7 +66,7 @@ function convertCategoryToNode(
   };
 }
 
-function convertScriptToNode(script: IScript): NodeMetadata {
+function convertScriptToNode(script: Script): NodeMetadata {
   return {
     id: getScriptNodeId(script),
     type: NodeType.Script,
diff --git a/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts b/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts
index 46a6387c..d9088f64 100644
--- a/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts
+++ b/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts
@@ -1,8 +1,8 @@
 import {
   type Ref, shallowReadonly, shallowRef,
 } from 'vue';
-import type { IScript } from '@/domain/IScript';
-import type { ICategory } from '@/domain/ICategory';
+import type { Script } from '@/domain/Executables/Script/Script';
+import type { Category } from '@/domain/Executables/Category/Category';
 import { injectKey } from '@/presentation/injectionSymbols';
 import type { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
 import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
@@ -76,10 +76,10 @@ function filterMatches(node: NodeMetadata, filter: FilterResult): boolean {
     || containsCategory(node, filter.categoryMatches);
 }
 
-function containsScript(expected: NodeMetadata, scripts: readonly IScript[]) {
-  return scripts.some((existing: IScript) => expected.id === getScriptNodeId(existing));
+function containsScript(expected: NodeMetadata, scripts: readonly Script[]) {
+  return scripts.some((existing: Script) => expected.id === getScriptNodeId(existing));
 }
 
-function containsCategory(expected: NodeMetadata, categories: readonly ICategory[]) {
-  return categories.some((existing: ICategory) => expected.id === getCategoryNodeId(existing));
+function containsCategory(expected: NodeMetadata, categories: readonly Category[]) {
+  return categories.some((existing: Category) => expected.id === getCategoryNodeId(existing));
 }
diff --git a/tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts b/tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts
index 18dee5ed..bdfc8a85 100644
--- a/tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts
+++ b/tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts
@@ -2,7 +2,8 @@ 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 type { ICategory, IScript } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
+import type { Script } from '@/domain/Executables/Script/Script';
 
 describe('AppliedFilterResult', () => {
   describe('constructor', () => {
@@ -68,18 +69,18 @@ describe('AppliedFilterResult', () => {
 });
 
 class ResultBuilder {
-  private scriptMatches: readonly IScript[] = [new ScriptStub('id')];
+  private scriptMatches: readonly Script[] = [new ScriptStub('id')];
 
-  private categoryMatches: readonly ICategory[] = [new CategoryStub(5)];
+  private categoryMatches: readonly Category[] = [new CategoryStub(5)];
 
   private query: string = `[${ResultBuilder.name}]query`;
 
-  public withScriptMatches(scriptMatches: readonly IScript[]): this {
+  public withScriptMatches(scriptMatches: readonly Script[]): this {
     this.scriptMatches = scriptMatches;
     return this;
   }
 
-  public withCategoryMatches(categoryMatches: readonly ICategory[]): this {
+  public withCategoryMatches(categoryMatches: readonly Category[]): this {
     this.categoryMatches = categoryMatches;
     return this;
   }
diff --git a/tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts b/tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts
index 21a73401..e2639a52 100644
--- a/tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts
+++ b/tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts
@@ -3,8 +3,8 @@ 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 type { ICategoryCollection } from '@/domain/ICategoryCollection';
-import type { ICategory } from '@/domain/ICategory';
-import type { IScript } from '@/domain/IScript';
+import type { Category } from '@/domain/Executables/Category/Category';
+import type { Script } from '@/domain/Executables/Script/Script';
 import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { LinearFilterStrategy } from '@/application/Context/State/Filter/Strategy/LinearFilterStrategy';
 
@@ -89,7 +89,7 @@ describe('LinearFilterStrategy', () => {
         interface ScriptMatchTestScenario {
           readonly description: string;
           readonly filter: string;
-          readonly matchingScript: IScript;
+          readonly matchingScript: Script;
         }
         const testScenarios: readonly ScriptMatchTestScenario[] = [
           {
@@ -134,7 +134,7 @@ describe('LinearFilterStrategy', () => {
       it('returns multiple matching scripts', () => {
         // arrange
         const filter = 'matching filter';
-        const matchingScripts: readonly IScript[] = [
+        const matchingScripts: readonly Script[] = [
           createMatchingScript(filter),
           createMatchingScript(filter),
         ];
@@ -165,7 +165,7 @@ describe('LinearFilterStrategy', () => {
         interface CategoryMatchTestScenario {
           readonly description: string;
           readonly filter: string;
-          readonly matchingCategory: ICategory;
+          readonly matchingCategory: Category;
         }
         const testScenarios: readonly CategoryMatchTestScenario[] = [
           {
@@ -200,7 +200,7 @@ describe('LinearFilterStrategy', () => {
       it('returns multiple matching categories', () => {
         // arrange
         const filter = 'matching filter';
-        const matchingCategories: readonly ICategory[] = [
+        const matchingCategories: readonly Category[] = [
           createMatchingCategory(filter),
           createMatchingCategory(filter),
         ];
@@ -237,7 +237,7 @@ function createMatchingCategory(
 
 function expectCategoryMatches(
   actualFilter: FilterResult,
-  expectedMatches: readonly ICategory[],
+  expectedMatches: readonly Category[],
 ): void {
   expect(actualFilter.hasAnyMatches()).be.equal(true);
   expect(actualFilter.categoryMatches).to.have.lengthOf(expectedMatches.length);
@@ -246,7 +246,7 @@ function expectCategoryMatches(
 
 function expectScriptMatches(
   actualFilter: FilterResult,
-  expectedMatches: readonly IScript[],
+  expectedMatches: readonly Script[],
 ): void {
   expect(actualFilter.hasAnyMatches()).be.equal(true);
   expect(actualFilter.scriptMatches).to.have.lengthOf(expectedMatches.length);
diff --git a/tests/unit/application/Context/State/Selection/Category/ScriptToCategorySelectionMapper.spec.ts b/tests/unit/application/Context/State/Selection/Category/ScriptToCategorySelectionMapper.spec.ts
index 878930f5..7c14ce4b 100644
--- a/tests/unit/application/Context/State/Selection/Category/ScriptToCategorySelectionMapper.spec.ts
+++ b/tests/unit/application/Context/State/Selection/Category/ScriptToCategorySelectionMapper.spec.ts
@@ -8,7 +8,8 @@ import { ScriptSelectionStub } from '@tests/unit/shared/Stubs/ScriptSelectionStu
 import type { CategorySelectionChange } from '@/application/Context/State/Selection/Category/CategorySelectionChange';
 import type { ScriptSelectionChange, ScriptSelectionChangeCommand } from '@/application/Context/State/Selection/Script/ScriptSelectionChange';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-import type { ICategory, IScript } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
+import type { Script } from '@/domain/Executables/Script/Script';
 
 describe('ScriptToCategorySelectionMapper', () => {
   describe('areAllScriptsSelected', () => {
@@ -64,8 +65,8 @@ describe('ScriptToCategorySelectionMapper', () => {
       readonly description: string;
       readonly changes: readonly CategorySelectionChange[];
       readonly categories: ReadonlyArray<{
-        readonly categoryId: ICategory['id'],
-        readonly scriptIds: readonly IScript['id'][],
+        readonly categoryId: Category['id'],
+        readonly scriptIds: readonly Script['id'][],
       }>;
       readonly expected: readonly ScriptSelectionChange[],
     }> = [
diff --git a/tests/unit/application/Context/State/Selection/Script/DebouncedScriptSelection.spec.ts b/tests/unit/application/Context/State/Selection/Script/DebouncedScriptSelection.spec.ts
index 28ee3e8d..3d840137 100644
--- a/tests/unit/application/Context/State/Selection/Script/DebouncedScriptSelection.spec.ts
+++ b/tests/unit/application/Context/State/Selection/Script/DebouncedScriptSelection.spec.ts
@@ -9,7 +9,7 @@ import type { SelectedScript } from '@/application/Context/State/Selection/Scrip
 import { BatchedDebounceStub } from '@tests/unit/shared/Stubs/BatchedDebounceStub';
 import type { ScriptSelectionChange, ScriptSelectionChangeCommand } from '@/application/Context/State/Selection/Script/ScriptSelectionChange';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { expectEqualSelectedScripts } from './ExpectEqualSelectedScripts';
 
 type DebounceArg = ScriptSelectionChangeCommand;
@@ -538,7 +538,7 @@ describe('DebouncedScriptSelection', () => {
   });
 });
 
-function createCollectionWithScripts(...scripts: IScript[]): CategoryCollectionStub {
+function createCollectionWithScripts(...scripts: Script[]): CategoryCollectionStub {
   const category = new CategoryStub(1).withScripts(...scripts);
   const collection = new CategoryCollectionStub().withAction(category);
   return collection;
diff --git a/tests/unit/application/Parser/CategoryCollectionParser.spec.ts b/tests/unit/application/Parser/CategoryCollectionParser.spec.ts
index 0d2dbb47..cec0dae2 100644
--- a/tests/unit/application/Parser/CategoryCollectionParser.spec.ts
+++ b/tests/unit/application/Parser/CategoryCollectionParser.spec.ts
@@ -1,14 +1,14 @@
 import { describe, it, expect } from 'vitest';
 import type { IEntity } from '@/infrastructure/Entity/IEntity';
 import { parseCategoryCollection } from '@/application/Parser/CategoryCollectionParser';
-import { parseCategory } from '@/application/Parser/CategoryParser';
+import { parseCategory } from '@/application/Parser/Executable/CategoryParser';
 import { OperatingSystem } from '@/domain/OperatingSystem';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
 import { ScriptingDefinitionParser } from '@/application/Parser/ScriptingDefinition/ScriptingDefinitionParser';
 import { EnumParserStub } from '@tests/unit/shared/Stubs/EnumParserStub';
 import { ProjectDetailsStub } from '@tests/unit/shared/Stubs/ProjectDetailsStub';
 import { getCategoryStub, CollectionDataStub } from '@tests/unit/shared/Stubs/CollectionDataStub';
-import { CategoryCollectionParseContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionParseContextStub';
+import { CategoryCollectionSpecificUtilitiesStub } from '@tests/unit/shared/Stubs/CategoryCollectionSpecificUtilitiesStub';
 import { CategoryDataStub } from '@tests/unit/shared/Stubs/CategoryDataStub';
 import { createScriptDataWithCall, createScriptDataWithCode } from '@tests/unit/shared/Stubs/ScriptDataStub';
 import { createFunctionDataWithCode } from '@tests/unit/shared/Stubs/FunctionDataStub';
@@ -35,7 +35,7 @@ describe('CategoryCollectionParser', () => {
       it('parses actions', () => {
         // arrange
         const actions = [getCategoryStub('test1'), getCategoryStub('test2')];
-        const context = new CategoryCollectionParseContextStub();
+        const context = new CategoryCollectionSpecificUtilitiesStub();
         const expected = [parseCategory(actions[0], context), parseCategory(actions[1], context)];
         const collection = new CollectionDataStub()
           .withActions(actions);
diff --git a/tests/unit/application/Parser/Executable/CategoryCollectionSpecificUtilities.spec.ts b/tests/unit/application/Parser/Executable/CategoryCollectionSpecificUtilities.spec.ts
new file mode 100644
index 00000000..82250473
--- /dev/null
+++ b/tests/unit/application/Parser/Executable/CategoryCollectionSpecificUtilities.spec.ts
@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import type { ISyntaxFactory } from '@/application/Parser/Executable/Script/Validation/Syntax/ISyntaxFactory';
+import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
+import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
+import { ScriptingDefinitionStub } from '@tests/unit/shared/Stubs/ScriptingDefinitionStub';
+import type { FunctionData } from '@/application/collections/';
+import { itEachAbsentCollectionValue } from '@tests/unit/shared/TestCases/AbsentTests';
+import { createFunctionDataWithCode } from '@tests/unit/shared/Stubs/FunctionDataStub';
+import { ScriptCompiler } from '@/application/Parser/Executable/Script/Compiler/ScriptCompiler';
+import { createCollectionUtilities } from '@/application/Parser/Executable/CategoryCollectionSpecificUtilities';
+import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
+import { createSyntaxFactoryStub } from '@tests/unit/shared/Stubs/SyntaxFactoryStub';
+
+describe('CategoryCollectionSpecificUtilities', () => {
+  describe('createCollectionUtilities', () => {
+    describe('functionsData', () => {
+      describe('can create with absent data', () => {
+        itEachAbsentCollectionValue<FunctionData>((absentValue) => {
+          // arrange
+          const context = new TextContext()
+            .withData(absentValue);
+          // act
+          const act = () => context.createCollectionUtilities();
+          // assert
+          expect(act).to.not.throw();
+        }, { excludeNull: true });
+      });
+    });
+  });
+  describe('compiler', () => {
+    it('constructed as expected', () => {
+      // arrange
+      const functionsData = [createFunctionDataWithCode()];
+      const syntax = new LanguageSyntaxStub();
+      const expected = new ScriptCompiler(functionsData, syntax);
+      const language = ScriptingLanguage.shellscript;
+      const factoryMock = createSyntaxFactoryStub(language, syntax);
+      const definition = new ScriptingDefinitionStub()
+        .withLanguage(language);
+      const context = new TextContext()
+        .withData(functionsData)
+        .withScripting(definition)
+        .withSyntaxFactory(factoryMock);
+      // act
+      const utilities = context.createCollectionUtilities();
+      // assert
+      const actual = utilities.compiler;
+      expect(actual).to.deep.equal(expected);
+    });
+  });
+  describe('syntax', () => {
+    it('set from syntax factory', () => {
+      // arrange
+      const language = ScriptingLanguage.shellscript;
+      const expected = new LanguageSyntaxStub();
+      const factoryMock = createSyntaxFactoryStub(language, expected);
+      const definition = new ScriptingDefinitionStub()
+        .withLanguage(language);
+      const context = new TextContext()
+        .withScripting(definition)
+        .withSyntaxFactory(factoryMock);
+      // act
+      const utilities = context.createCollectionUtilities();
+      // assert
+      const actual = utilities.syntax;
+      expect(actual).to.equal(expected);
+    });
+  });
+});
+
+class TextContext {
+  private functionsData: readonly FunctionData[] | undefined = [createFunctionDataWithCode()];
+
+  private scripting: IScriptingDefinition = new ScriptingDefinitionStub();
+
+  private syntaxFactory: ISyntaxFactory = createSyntaxFactoryStub();
+
+  public withScripting(scripting: IScriptingDefinition): this {
+    this.scripting = scripting;
+    return this;
+  }
+
+  public withData(data: readonly FunctionData[] | undefined): this {
+    this.functionsData = data;
+    return this;
+  }
+
+  public withSyntaxFactory(syntaxFactory: ISyntaxFactory): this {
+    this.syntaxFactory = syntaxFactory;
+    return this;
+  }
+
+  public createCollectionUtilities(): ReturnType<typeof createCollectionUtilities> {
+    return createCollectionUtilities(
+      this.functionsData,
+      this.scripting,
+      this.syntaxFactory,
+    );
+  }
+}
diff --git a/tests/unit/application/Parser/CategoryParser.spec.ts b/tests/unit/application/Parser/Executable/CategoryParser.spec.ts
similarity index 82%
rename from tests/unit/application/Parser/CategoryParser.spec.ts
rename to tests/unit/application/Parser/Executable/CategoryParser.spec.ts
index e1de049f..7b668e78 100644
--- a/tests/unit/application/Parser/CategoryParser.spec.ts
+++ b/tests/unit/application/Parser/Executable/CategoryParser.spec.ts
@@ -1,19 +1,18 @@
 import { describe, it, expect } from 'vitest';
-import type { CategoryData, CategoryOrScriptData } from '@/application/collections/';
-import { type CategoryFactory, parseCategory } from '@/application/Parser/CategoryParser';
-import { type ScriptParser } from '@/application/Parser/Script/ScriptParser';
-import { type DocsParser } from '@/application/Parser/DocumentationParser';
-import { CategoryCollectionParseContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionParseContextStub';
+import type { CategoryData, ExecutableData } from '@/application/collections/';
+import { type CategoryFactory, parseCategory } from '@/application/Parser/Executable/CategoryParser';
+import { type ScriptParser } from '@/application/Parser/Executable/Script/ScriptParser';
+import { type DocsParser } from '@/application/Parser/Executable/DocumentationParser';
+import { CategoryCollectionSpecificUtilitiesStub } from '@tests/unit/shared/Stubs/CategoryCollectionSpecificUtilitiesStub';
 import { CategoryDataStub } from '@tests/unit/shared/Stubs/CategoryDataStub';
 import { getAbsentCollectionTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
-import { NodeDataType } from '@/application/Parser/NodeValidation/NodeDataType';
-import type { ICategoryCollectionParseContext } from '@/application/Parser/Script/ICategoryCollectionParseContext';
+import { ExecutableType } from '@/application/Parser/Executable/Validation/ExecutableType';
 import { createScriptDataWithCall, createScriptDataWithCode } from '@tests/unit/shared/Stubs/ScriptDataStub';
 import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { ErrorWrapperStub } from '@tests/unit/shared/Stubs/ErrorWrapperStub';
-import type { NodeDataValidatorFactory } from '@/application/Parser/NodeValidation/NodeDataValidator';
-import { NodeDataValidatorStub, createNodeDataValidatorFactoryStub } from '@tests/unit/shared/Stubs/NodeDataValidatorStub';
-import type { CategoryNodeErrorContext, UnknownNodeErrorContext } from '@/application/Parser/NodeValidation/NodeDataErrorContext';
+import type { ExecutableValidatorFactory } from '@/application/Parser/Executable/Validation/ExecutableValidator';
+import { ExecutableValidatorStub, createExecutableValidatorFactoryStub } from '@tests/unit/shared/Stubs/ExecutableValidatorStub';
+import type { CategoryErrorContext, UnknownExecutableErrorContext } from '@/application/Parser/Executable/Validation/ExecutableErrorContext';
 import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
 import { createCategoryFactorySpy } from '@tests/unit/shared/Stubs/CategoryFactoryStub';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
@@ -21,9 +20,9 @@ import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 import { ScriptParserStub } from '@tests/unit/shared/Stubs/ScriptParserStub';
 import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
 import { indentText } from '@tests/shared/Text';
-import { itThrowsContextualError } from './ContextualErrorTester';
-import { itValidatesName, itValidatesDefinedData, itAsserts } from './NodeDataValidationTester';
-import { generateDataValidationTestScenarios } from './DataValidationTestScenarioGenerator';
+import { itThrowsContextualError } from '../ContextualErrorTester';
+import { itValidatesName, itValidatesDefinedData, itAsserts } from './Validation/ExecutableValidationTester';
+import { generateDataValidationTestScenarios } from './Validation/DataValidationTestScenarioGenerator';
 
 describe('CategoryParser', () => {
   describe('parseCategory', () => {
@@ -33,9 +32,9 @@ describe('CategoryParser', () => {
         const expectedName = 'expected category name to be validated';
         const category = new CategoryDataStub()
           .withName(expectedName);
-        const expectedContext: CategoryNodeErrorContext = {
-          type: NodeDataType.Category,
-          selfNode: category,
+        const expectedContext: CategoryErrorContext = {
+          type: ExecutableType.Category,
+          self: category,
         };
         itValidatesName((validatorFactory) => {
           // act
@@ -53,9 +52,9 @@ describe('CategoryParser', () => {
       describe('validates for defined data', () => {
         // arrange
         const category = new CategoryDataStub();
-        const expectedContext: CategoryNodeErrorContext = {
-          type: NodeDataType.Category,
-          selfNode: category,
+        const expectedContext: CategoryErrorContext = {
+          type: ExecutableType.Category,
+          self: category,
         };
         itValidatesDefinedData(
           (validatorFactory) => {
@@ -75,13 +74,13 @@ describe('CategoryParser', () => {
       describe('validates that category has some children', () => {
         const categoryName = 'test';
         const testScenarios = generateDataValidationTestScenarios<CategoryData>({
-          expectFail: getAbsentCollectionTestCases<CategoryOrScriptData>().map(({
+          expectFail: getAbsentCollectionTestCases<ExecutableData>().map(({
             valueName, absentValue: absentCollectionValue,
           }) => ({
             description: `with \`${valueName}\` value as children`,
             data: new CategoryDataStub()
               .withName(categoryName)
-              .withChildren(absentCollectionValue as unknown as CategoryOrScriptData[]),
+              .withChildren(absentCollectionValue as unknown as ExecutableData[]),
           })),
           expectPass: [{
             description: 'has single children',
@@ -98,9 +97,9 @@ describe('CategoryParser', () => {
               expectedConditionResult: expectedPass,
               test: (validatorFactory) => {
                 const expectedMessage = `"${categoryName}" has no children.`;
-                const expectedContext: CategoryNodeErrorContext = {
-                  type: NodeDataType.Category,
-                  selfNode: categoryData,
+                const expectedContext: CategoryErrorContext = {
+                  type: ExecutableType.Category,
+                  self: categoryData,
                 };
                 // act
                 try {
@@ -121,10 +120,10 @@ describe('CategoryParser', () => {
       });
       describe('validates that a child is a category or a script', () => {
         // arrange
-        const testScenarios = generateDataValidationTestScenarios<CategoryOrScriptData>({
+        const testScenarios = generateDataValidationTestScenarios<ExecutableData>({
           expectFail: [{
             description: 'child has incorrect properties',
-            data: { property: 'non-empty-value' } as unknown as CategoryOrScriptData,
+            data: { property: 'non-empty-value' } as unknown as ExecutableData,
           }],
           expectPass: [
             {
@@ -148,13 +147,13 @@ describe('CategoryParser', () => {
             itAsserts({
               expectedConditionResult: expectedPass,
               test: (validatorFactory) => {
-                const expectedError = 'Node is neither a category or a script.';
+                const expectedError = 'Executable is neither a category or a script.';
                 const parent = new CategoryDataStub()
                   .withName('parent')
                   .withChildren([new CategoryDataStub().withName('valid child'), childData]);
-                const expectedContext: UnknownNodeErrorContext = {
-                  selfNode: childData,
-                  parentNode: parent,
+                const expectedContext: UnknownExecutableErrorContext = {
+                  self: childData,
+                  parentCategory: parent,
                 };
                 // act
                 new TestBuilder()
@@ -180,9 +179,9 @@ describe('CategoryParser', () => {
           const parent = new CategoryDataStub()
             .withName('parent')
             .withChildren([child]);
-          const expectedContext: UnknownNodeErrorContext = {
-            selfNode: child,
-            parentNode: parent,
+          const expectedContext: UnknownExecutableErrorContext = {
+            self: child,
+            parentCategory: parent,
           };
           itValidatesDefinedData(
             (validatorFactory) => {
@@ -210,10 +209,10 @@ describe('CategoryParser', () => {
           const parent = new CategoryDataStub()
             .withName('parent')
             .withChildren([child]);
-          const expectedContext: CategoryNodeErrorContext = {
-            type: NodeDataType.Category,
-            selfNode: grandChild,
-            parentNode: child,
+          const expectedContext: CategoryErrorContext = {
+            type: ExecutableType.Category,
+            self: grandChild,
+            parentCategory: child,
           };
           itValidatesName((validatorFactory) => {
             // act
@@ -238,7 +237,7 @@ describe('CategoryParser', () => {
       // act & assert
       itThrowsContextualError({
         throwingAction: (wrapError) => {
-          const validatorStub = new NodeDataValidatorStub();
+          const validatorStub = new ExecutableValidatorStub();
           validatorStub.createContextualErrorMessage = (message) => message;
           const factoryMock: CategoryFactory = () => {
             throw expectedError;
@@ -328,9 +327,9 @@ describe('CategoryParser', () => {
         expect(actualParsedScripts.length).to.equal(expectedScripts.length);
         expect(actualParsedScripts).to.have.members(expectedScripts);
       });
-      it('parses all scripts with correct context', () => {
+      it('parses all scripts with correct utilities', () => {
         // arrange
-        const expectedParseContext = new CategoryCollectionParseContextStub();
+        const expected = new CategoryCollectionSpecificUtilitiesStub();
         const scriptParser = new ScriptParserStub();
         const childrenData = [
           createScriptDataWithCode(),
@@ -343,24 +342,24 @@ describe('CategoryParser', () => {
         // act
         const actualCategory = new TestBuilder()
           .withData(categoryData)
-          .withContext(expectedParseContext)
+          .withCollectionUtilities(expected)
           .withScriptParser(scriptParser.get())
           .withCategoryFactory(categoryFactorySpy)
           .parseCategory();
         // assert
         const actualParsedScripts = getInitParameters(actualCategory)?.scripts;
         expectExists(actualParsedScripts);
-        const actualParseContexts = actualParsedScripts.map(
+        const actualUtilities = actualParsedScripts.map(
           (s) => scriptParser.getParseParameters(s)[1],
         );
         expect(
-          actualParseContexts.every(
-            (actualParseContext) => actualParseContext === expectedParseContext,
+          actualUtilities.every(
+            (actual) => actual === expected,
           ),
           formatAssertionMessage([
-            `Expected all elements to be ${JSON.stringify(expectedParseContext)}`,
+            `Expected all elements to be ${JSON.stringify(expected)}`,
             'All elements:',
-            indentText(JSON.stringify(actualParseContexts)),
+            indentText(JSON.stringify(actualUtilities)),
           ]),
         ).to.equal(true);
       });
@@ -397,13 +396,14 @@ describe('CategoryParser', () => {
 class TestBuilder {
   private data: CategoryData = new CategoryDataStub();
 
-  private context: ICategoryCollectionParseContext = new CategoryCollectionParseContextStub();
+  private collectionUtilities:
+  CategoryCollectionSpecificUtilitiesStub = new CategoryCollectionSpecificUtilitiesStub();
 
   private categoryFactory: CategoryFactory = () => new CategoryStub(33);
 
   private errorWrapper: ErrorWithContextWrapper = new ErrorWrapperStub().get();
 
-  private validatorFactory: NodeDataValidatorFactory = createNodeDataValidatorFactoryStub;
+  private validatorFactory: ExecutableValidatorFactory = createExecutableValidatorFactoryStub;
 
   private docsParser: DocsParser = () => ['docs'];
 
@@ -414,8 +414,10 @@ class TestBuilder {
     return this;
   }
 
-  public withContext(context: ICategoryCollectionParseContext): this {
-    this.context = context;
+  public withCollectionUtilities(
+    collectionUtilities: CategoryCollectionSpecificUtilitiesStub,
+  ): this {
+    this.collectionUtilities = collectionUtilities;
     return this;
   }
 
@@ -424,7 +426,7 @@ class TestBuilder {
     return this;
   }
 
-  public withValidatorFactory(validatorFactory: NodeDataValidatorFactory): this {
+  public withValidatorFactory(validatorFactory: ExecutableValidatorFactory): this {
     this.validatorFactory = validatorFactory;
     return this;
   }
@@ -447,7 +449,7 @@ class TestBuilder {
   public parseCategory() {
     return parseCategory(
       this.data,
-      this.context,
+      this.collectionUtilities,
       {
         createCategory: this.categoryFactory,
         wrapError: this.errorWrapper,
diff --git a/tests/unit/application/Parser/DocumentationParser.spec.ts b/tests/unit/application/Parser/Executable/DocumentationParser.spec.ts
similarity index 80%
rename from tests/unit/application/Parser/DocumentationParser.spec.ts
rename to tests/unit/application/Parser/Executable/DocumentationParser.spec.ts
index 88aa0e45..507961b9 100644
--- a/tests/unit/application/Parser/DocumentationParser.spec.ts
+++ b/tests/unit/application/Parser/Executable/DocumentationParser.spec.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import type { DocumentableData } from '@/application/collections/';
-import { parseDocs } from '@/application/Parser/DocumentationParser';
+import { parseDocs } from '@/application/Parser/Executable/DocumentationParser';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
 
 describe('DocumentationParser', () => {
@@ -9,9 +9,9 @@ describe('DocumentationParser', () => {
       itEachAbsentStringValue((absentValue) => {
         // arrange
         const expectedError = 'missing documentation';
-        const node: DocumentableData = { docs: ['non empty doc 1', absentValue] };
+        const data: DocumentableData = { docs: ['non empty doc 1', absentValue] };
         // act
-        const act = () => parseDocs(node);
+        const act = () => parseDocs(data);
         // assert
         expect(act).to.throw(expectedError);
       }, { excludeNull: true, excludeUndefined: true });
@@ -20,20 +20,23 @@ describe('DocumentationParser', () => {
       // arrange
       const expectedTypeError = 'docs field (documentation) must be an array of strings';
       const wrongTypedValue = 22 as never;
-      const testCases: ReadonlyArray<{ name: string, node: DocumentableData }> = [
+      const testCases: ReadonlyArray<{
+        readonly name: string;
+        readonly data: DocumentableData;
+      }> = [
         {
           name: 'given docs',
-          node: { docs: wrongTypedValue },
+          data: { docs: wrongTypedValue },
         },
         {
           name: 'single doc',
-          node: { docs: ['non empty doc 1', wrongTypedValue] },
+          data: { docs: ['non empty doc 1', wrongTypedValue] },
         },
       ];
       for (const testCase of testCases) {
         it(testCase.name, () => {
           // act
-          const act = () => parseDocs(testCase.node);
+          const act = () => parseDocs(testCase.data);
           // assert
           expect(act).to.throw(expectedTypeError);
         });
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Expression/Expression.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/Expression.spec.ts
similarity index 93%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Expression/Expression.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/Expression.spec.ts
index 31203f34..36fff888 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Expression/Expression.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/Expression.spec.ts
@@ -1,16 +1,16 @@
 import { describe, it, expect } from 'vitest';
-import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
-import { type ExpressionEvaluator, Expression } from '@/application/Parser/Script/Compiler/Expressions/Expression/Expression';
-import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
+import { ExpressionPosition } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition';
+import { type ExpressionEvaluator, Expression } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/Expression';
+import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
 import { FunctionCallArgumentCollectionStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub';
 import { FunctionParameterCollectionStub } from '@tests/unit/shared/Stubs/FunctionParameterCollectionStub';
 import { FunctionCallArgumentStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentStub';
 import { ExpressionEvaluationContextStub } from '@tests/unit/shared/Stubs/ExpressionEvaluationContextStub';
-import type { IPipelineCompiler } from '@/application/Parser/Script/Compiler/Expressions/Pipes/IPipelineCompiler';
+import type { IPipelineCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipelineCompiler';
 import { PipelineCompilerStub } from '@tests/unit/shared/Stubs/PipelineCompilerStub';
-import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
+import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
 import { itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import type { IExpressionEvaluationContext } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
+import type { IExpressionEvaluationContext } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.spec.ts
similarity index 84%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.spec.ts
index 3d1e9aa2..9bb2b100 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.spec.ts
@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
-import { ExpressionEvaluationContext, type IExpressionEvaluationContext } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
-import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
-import type { IPipelineCompiler } from '@/application/Parser/Script/Compiler/Expressions/Pipes/IPipelineCompiler';
+import { ExpressionEvaluationContext, type IExpressionEvaluationContext } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
+import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
+import type { IPipelineCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipelineCompiler';
 import { FunctionCallArgumentCollectionStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub';
 import { PipelineCompilerStub } from '@tests/unit/shared/Stubs/PipelineCompilerStub';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition.spec.ts
similarity index 98%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition.spec.ts
index b430dba1..eb707dd6 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition.spec.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
+import { ExpressionPosition } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition';
 
 describe('ExpressionPosition', () => {
   describe('ctor', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.spec.ts
similarity index 94%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.spec.ts
index ce7e66e5..165a6beb 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.spec.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import { createPositionFromRegexFullMatch } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory';
-import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
+import { createPositionFromRegexFullMatch } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPositionFactory';
+import { ExpressionPosition } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition';
 import { itIsTransientFactory } from '@tests/unit/shared/TestCases/TransientFactoryTests';
 
 describe('ExpressionPositionFactory', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler.spec.ts
similarity index 97%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler.spec.ts
index dfdc043f..7bc6e105 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler.spec.ts
@@ -1,11 +1,11 @@
 import { describe, it, expect } from 'vitest';
-import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
-import type { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
+import { ExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler';
+import type { IExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser';
 import { ExpressionStub } from '@tests/unit/shared/Stubs/ExpressionStub';
 import { ExpressionParserStub } from '@tests/unit/shared/Stubs/ExpressionParserStub';
 import { FunctionCallArgumentCollectionStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import type { IExpression } from '@/application/Parser/Script/Compiler/Expressions/Expression/IExpression';
+import type { IExpression } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/IExpression';
 
 describe('ExpressionsCompiler', () => {
   describe('compileExpressions', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/CompositeExpressionParser.spec.ts
similarity index 89%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/CompositeExpressionParser.spec.ts
index d3766bab..b978d7d1 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/CompositeExpressionParser.spec.ts
@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
-import type { IExpression } from '@/application/Parser/Script/Compiler/Expressions/Expression/IExpression';
-import type { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
-import { CompositeExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser';
+import type { IExpression } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/IExpression';
+import type { IExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser';
+import { CompositeExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/CompositeExpressionParser';
 import { ExpressionStub } from '@tests/unit/shared/Stubs/ExpressionStub';
 import { itEachAbsentCollectionValue } from '@tests/unit/shared/TestCases/AbsentTests';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.spec.ts
similarity index 98%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.spec.ts
index 1409ebc8..40882633 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder.spec.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { ExpressionRegexBuilder } from '@/application/Parser/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder';
+import { ExpressionRegexBuilder } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/ExpressionRegexBuilder';
 
 const AllWhitespaceCharacters = ' \t\n\r\v\f\u00A0';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/RegexParser.spec.ts
similarity index 95%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/RegexParser.spec.ts
index 807ce273..0283dae5 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/RegexParser.spec.ts
@@ -1,23 +1,23 @@
 import { describe, it, expect } from 'vitest';
 import type {
   ExpressionEvaluator, ExpressionInitParameters,
-} from '@/application/Parser/Script/Compiler/Expressions/Expression/Expression';
+} from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/Expression';
 import {
   type PrimitiveExpression, RegexParser, type ExpressionFactory, type RegexParserUtilities,
-} from '@/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser';
-import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
+} from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/RegexParser';
+import { ExpressionPosition } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
 import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
 import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
 import { ExpressionStub } from '@tests/unit/shared/Stubs/ExpressionStub';
 import { FunctionParameterCollectionStub } from '@tests/unit/shared/Stubs/FunctionParameterCollectionStub';
-import type { IExpression } from '@/application/Parser/Script/Compiler/Expressions/Expression/IExpression';
+import type { IExpression } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/IExpression';
 import { FunctionParameterStub } from '@tests/unit/shared/Stubs/FunctionParameterStub';
-import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
-import type { ExpressionPositionFactory } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory';
+import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
+import type { ExpressionPositionFactory } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPositionFactory';
 import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
 import { indentText } from '@tests/shared/Text';
-import type { FunctionParameterCollectionFactory } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
+import type { FunctionParameterCollectionFactory } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
 
 describe('RegexParser', () => {
   describe('findExpressions', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.spec.ts
similarity index 87%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.spec.ts
index 30b7e572..ff812b7e 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.spec.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { EscapeDoubleQuotes } from '@/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes';
+import { EscapeDoubleQuotes } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes';
 import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
 import { runPipeTests } from './PipeTestRunner';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.spec.ts
similarity index 99%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.spec.ts
index cfd55d2b..9ca4ac91 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.spec.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { InlinePowerShell } from '@/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell';
+import { InlinePowerShell } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell';
 import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
 import { type IPipeTestCase, runPipeTests } from './PipeTestRunner';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/PipeTestRunner.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/PipeTestRunner.ts
similarity index 81%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/PipeTestRunner.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/PipeTestRunner.ts
index a31f2e7b..8a4349fc 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/PipeTestRunner.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeDefinitions/PipeTestRunner.ts
@@ -1,5 +1,5 @@
 import { it, expect } from 'vitest';
-import type { IPipe } from '@/application/Parser/Script/Compiler/Expressions/Pipes/IPipe';
+import type { IPipe } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipe';
 
 export interface IPipeTestCase {
   readonly name: string;
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeFactory.spec.ts
similarity index 96%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeFactory.spec.ts
index 2386d55f..f5222ecd 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeFactory.spec.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { PipeFactory } from '@/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory';
+import { PipeFactory } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeFactory';
 import { PipeStub } from '@tests/unit/shared/Stubs/PipeStub';
 import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipelineCompiler.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipelineCompiler.spec.ts
similarity index 92%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipelineCompiler.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipelineCompiler.spec.ts
index 0eef39ad..381318b6 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipelineCompiler.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipelineCompiler.spec.ts
@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
-import { PipelineCompiler } from '@/application/Parser/Script/Compiler/Expressions/Pipes/PipelineCompiler';
-import { type IPipelineCompiler } from '@/application/Parser/Script/Compiler/Expressions/Pipes/IPipelineCompiler';
-import type { IPipeFactory } from '@/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory';
+import { PipelineCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipelineCompiler';
+import { type IPipelineCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipelineCompiler';
+import type { IPipeFactory } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeFactory';
 import { PipeStub } from '@tests/unit/shared/Stubs/PipeStub';
 import { PipeFactoryStub } from '@tests/unit/shared/Stubs/PipeFactoryStub';
 import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.spec.ts
similarity index 90%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.spec.ts
index 65144784..c1355125 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.spec.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
-import { ParameterSubstitutionParser } from '@/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser';
-import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
+import { ParameterSubstitutionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser';
+import { ExpressionPosition } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition';
 import { SyntaxParserTestsRunner } from './SyntaxParserTestsRunner';
 
 describe('ParameterSubstitutionParser', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/SyntaxParsers/SyntaxParserTestsRunner.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/SyntaxParserTestsRunner.ts
similarity index 95%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/SyntaxParsers/SyntaxParserTestsRunner.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/SyntaxParserTestsRunner.ts
index 61c9eb05..0eba4c84 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/SyntaxParsers/SyntaxParserTestsRunner.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/SyntaxParserTestsRunner.ts
@@ -1,6 +1,6 @@
 import { it, expect } from 'vitest';
-import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
-import type { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
+import { ExpressionPosition } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition';
+import type { IExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser';
 import { FunctionCallArgumentCollectionStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub';
 import { ExpressionEvaluationContextStub } from '@tests/unit/shared/Stubs/ExpressionEvaluationContextStub';
 import { PipelineCompilerStub } from '@tests/unit/shared/Stubs/PipelineCompilerStub';
diff --git a/tests/unit/application/Parser/Script/Compiler/Expressions/SyntaxParsers/WithParser.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/WithParser.spec.ts
similarity index 97%
rename from tests/unit/application/Parser/Script/Compiler/Expressions/SyntaxParsers/WithParser.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/WithParser.spec.ts
index a27113b4..99fa809a 100644
--- a/tests/unit/application/Parser/Script/Compiler/Expressions/SyntaxParsers/WithParser.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/WithParser.spec.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
-import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
-import { WithParser } from '@/application/Parser/Script/Compiler/Expressions/SyntaxParsers/WithParser';
+import { ExpressionPosition } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition';
+import { WithParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/WithParser';
 import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
 import { SyntaxParserTestsRunner } from './SyntaxParserTestsRunner';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument.spec.ts
similarity index 92%
rename from tests/unit/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument.spec.ts
index 720aed9d..bd3cb4b1 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument.spec.ts
@@ -1,5 +1,5 @@
 import { describe, expect } from 'vitest';
-import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
+import { FunctionCallArgument } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
 import { testParameterName } from '../../../ParameterNameTestRunner';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.spec.ts
similarity index 96%
rename from tests/unit/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.spec.ts
index e14edc35..b29122ca 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.spec.ts
@@ -1,8 +1,8 @@
 import { describe, it, expect } from 'vitest';
-import { FunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
+import { FunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
 import { FunctionCallArgumentStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentStub';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import type { IFunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgument';
+import type { IFunctionCallArgument } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgument';
 
 describe('FunctionCallArgumentCollection', () => {
   describe('addArgument', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.spec.ts
similarity index 93%
rename from tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.spec.ts
index 241bbe9d..b6551b83 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.spec.ts
@@ -1,8 +1,8 @@
 import { expect, describe, it } from 'vitest';
-import { NewlineCodeSegmentMerger } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger';
+import { NewlineCodeSegmentMerger } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger';
 import { CompiledCodeStub } from '@tests/unit/shared/Stubs/CompiledCodeStub';
 import { getAbsentStringTestCases, itEachAbsentCollectionValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
 
 describe('NewlineCodeSegmentMerger', () => {
   describe('mergeCodeParts', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.spec.ts
similarity index 93%
rename from tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.spec.ts
index 8a8b0a53..06333270 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.spec.ts
@@ -1,18 +1,18 @@
 /* eslint-disable max-classes-per-file */
 import { describe, it, expect } from 'vitest';
-import { FunctionCallSequenceCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler';
+import { FunctionCallSequenceCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler';
 import { itIsSingletonFactory } from '@tests/unit/shared/TestCases/SingletonFactoryTests';
 import { itEachAbsentCollectionValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import type { SingleCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler';
-import type { CodeSegmentMerger } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/CodeSegmentMerger';
-import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { SingleCallCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler';
+import type { CodeSegmentMerger } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/CodeSegmentMerger';
+import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import { FunctionCallStub } from '@tests/unit/shared/Stubs/FunctionCallStub';
 import { SharedFunctionCollectionStub } from '@tests/unit/shared/Stubs/SharedFunctionCollectionStub';
 import { SingleCallCompilerStub } from '@tests/unit/shared/Stubs/SingleCallCompilerStub';
 import { CodeSegmentMergerStub } from '@tests/unit/shared/Stubs/CodeSegmentMergerStub';
 import { CompiledCodeStub } from '@tests/unit/shared/Stubs/CompiledCodeStub';
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 
 describe('FunctionCallSequenceCompiler', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/NestedFunctionCallCompiler.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/NestedFunctionCallCompiler.spec.ts
similarity index 96%
rename from tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/NestedFunctionCallCompiler.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/NestedFunctionCallCompiler.spec.ts
index 04fe955c..3063875f 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/NestedFunctionCallCompiler.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/NestedFunctionCallCompiler.spec.ts
@@ -1,14 +1,14 @@
 import { expect, describe, it } from 'vitest';
 import { createSharedFunctionStubWithCalls, createSharedFunctionStubWithCode } from '@tests/unit/shared/Stubs/SharedFunctionStub';
-import { NestedFunctionCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler';
-import type { ArgumentCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler';
+import { NestedFunctionCallCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler';
+import type { ArgumentCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler';
 import { ArgumentCompilerStub } from '@tests/unit/shared/Stubs/ArgumentCompilerStub';
 import { FunctionCallStub } from '@tests/unit/shared/Stubs/FunctionCallStub';
 import { FunctionCallCompilationContextStub } from '@tests/unit/shared/Stubs/FunctionCallCompilationContextStub';
 import { SingleCallCompilerStub } from '@tests/unit/shared/Stubs/SingleCallCompilerStub';
 import { CompiledCodeStub } from '@tests/unit/shared/Stubs/CompiledCodeStub';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
 import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
 import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/AdaptiveFunctionCallCompiler.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/AdaptiveFunctionCallCompiler.spec.ts
similarity index 95%
rename from tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/AdaptiveFunctionCallCompiler.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/AdaptiveFunctionCallCompiler.spec.ts
index 70b86529..3c817e74 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/AdaptiveFunctionCallCompiler.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/AdaptiveFunctionCallCompiler.spec.ts
@@ -3,14 +3,14 @@ import { createSharedFunctionStubWithCode } from '@tests/unit/shared/Stubs/Share
 import type { FunctionCallParametersData } from '@/application/collections/';
 import { FunctionCallStub } from '@tests/unit/shared/Stubs/FunctionCallStub';
 import { SharedFunctionCollectionStub } from '@tests/unit/shared/Stubs/SharedFunctionCollectionStub';
-import { AdaptiveFunctionCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/AdaptiveFunctionCallCompiler';
-import type { SingleCallCompilerStrategy } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy';
+import { AdaptiveFunctionCallCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/AdaptiveFunctionCallCompiler';
+import type { SingleCallCompilerStrategy } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy';
 import { SingleCallCompilerStrategyStub } from '@tests/unit/shared/Stubs/SingleCallCompilerStrategyStub';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
 import { FunctionCallCompilationContextStub } from '@tests/unit/shared/Stubs/FunctionCallCompilationContextStub';
 import { CompiledCodeStub } from '@tests/unit/shared/Stubs/CompiledCodeStub';
-import type { SingleCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler';
+import type { SingleCallCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler';
 import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
 
 describe('AdaptiveFunctionCallCompiler', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.spec.ts
similarity index 96%
rename from tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.spec.ts
index 1a2e355c..1d85c410 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.spec.ts
@@ -1,9 +1,9 @@
 import { expect, describe, it } from 'vitest';
-import type { ArgumentCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import { NestedFunctionArgumentCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler';
-import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
+import type { ArgumentCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import { NestedFunctionArgumentCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
 import { ExpressionsCompilerStub } from '@tests/unit/shared/Stubs/ExpressionsCompilerStub';
 import { FunctionCallCompilationContextStub } from '@tests/unit/shared/Stubs/FunctionCallCompilationContextStub';
 import { FunctionCallStub } from '@tests/unit/shared/Stubs/FunctionCallStub';
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.spec.ts
similarity index 97%
rename from tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.spec.ts
index 6da57470..fa31682f 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.spec.ts
@@ -1,8 +1,8 @@
 import { expect, describe, it } from 'vitest';
-import { InlineFunctionCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler';
+import { InlineFunctionCallCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler';
 import { createSharedFunctionStubWithCode, createSharedFunctionStubWithCalls } from '@tests/unit/shared/Stubs/SharedFunctionStub';
 import { ExpressionsCompilerStub } from '@tests/unit/shared/Stubs/ExpressionsCompilerStub';
-import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
 import { FunctionCallStub } from '@tests/unit/shared/Stubs/FunctionCallStub';
 import { FunctionCallArgumentCollectionStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Call/FunctionCallParser.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCallParser.spec.ts
similarity index 96%
rename from tests/unit/application/Parser/Script/Compiler/Function/Call/FunctionCallParser.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCallParser.spec.ts
index 748448c3..152df25e 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Call/FunctionCallParser.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCallParser.spec.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseFunctionCalls } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCallParser';
+import { parseFunctionCalls } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCallParser';
 import { FunctionCallDataStub } from '@tests/unit/shared/Stubs/FunctionCallDataStub';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Call/ParsedFunctionCall.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/ParsedFunctionCall.spec.ts
similarity index 90%
rename from tests/unit/application/Parser/Script/Compiler/Function/Call/ParsedFunctionCall.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/ParsedFunctionCall.spec.ts
index 8c772c5f..9f93f881 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Call/ParsedFunctionCall.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Call/ParsedFunctionCall.spec.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import { ParsedFunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/ParsedFunctionCall';
-import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
+import { ParsedFunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/ParsedFunctionCall';
+import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
 import { FunctionCallArgumentCollectionStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/ExpectFunctionBodyType.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/ExpectFunctionBodyType.ts
similarity index 80%
rename from tests/unit/application/Parser/Script/Compiler/Function/ExpectFunctionBodyType.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/ExpectFunctionBodyType.ts
index e8c8e09f..fd355d44 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/ExpectFunctionBodyType.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/ExpectFunctionBodyType.ts
@@ -1,7 +1,7 @@
 import type {
   CallFunctionBody, CodeFunctionBody, SharedFunctionBody,
-} from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import { FunctionBodyType } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+} from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
+import { FunctionBodyType } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
 import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
 
 export function expectCodeFunctionBody(
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter.spec.ts
similarity index 90%
rename from tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter.spec.ts
index db438c67..0d16dcd9 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter.spec.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
+import { FunctionParameter } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter';
 import { testParameterName } from '../../ParameterNameTestRunner';
 
 describe('FunctionParameter', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection.spec.ts
similarity index 94%
rename from tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection.spec.ts
index 78eee79e..f488064b 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection.spec.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { FunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection';
 import { FunctionParameterStub } from '@tests/unit/shared/Stubs/FunctionParameterStub';
 
 describe('FunctionParameterCollection', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.spec.ts
similarity index 83%
rename from tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.spec.ts
index 99ad4ec4..07351ba5 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.spec.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
-import { createFunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
+import { FunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { createFunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
 import { itIsTransientFactory } from '@tests/unit/shared/TestCases/TransientFactoryTests';
 
 describe('FunctionParameterCollectionFactory', () => {
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/SharedFunction.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/SharedFunction.spec.ts
similarity index 95%
rename from tests/unit/application/Parser/Script/Compiler/Function/SharedFunction.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/SharedFunction.spec.ts
index 95f8c3b1..865d58e6 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/SharedFunction.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/SharedFunction.spec.ts
@@ -1,10 +1,10 @@
 import { describe, it, expect } from 'vitest';
-import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
+import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
 import { FunctionParameterCollectionStub } from '@tests/unit/shared/Stubs/FunctionParameterCollectionStub';
-import { createCallerFunction, createFunctionWithInlineCode } from '@/application/Parser/Script/Compiler/Function/SharedFunction';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import { createCallerFunction, createFunctionWithInlineCode } from '@/application/Parser/Executable/Script/Compiler/Function/SharedFunction';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import { FunctionCallStub } from '@tests/unit/shared/Stubs/FunctionCallStub';
-import { type CallFunctionBody, FunctionBodyType, type ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import { type CallFunctionBody, FunctionBodyType, type ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
 import {
   getAbsentStringTestCases, itEachAbsentCollectionValue,
   itEachAbsentStringValue,
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/SharedFunctionCollection.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/SharedFunctionCollection.spec.ts
similarity index 95%
rename from tests/unit/application/Parser/Script/Compiler/Function/SharedFunctionCollection.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/SharedFunctionCollection.spec.ts
index f5019f2b..1bcb5665 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/SharedFunctionCollection.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/SharedFunctionCollection.spec.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { SharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/SharedFunctionCollection';
+import { SharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/SharedFunctionCollection';
 import { createSharedFunctionStubWithCode, createSharedFunctionStubWithCalls } from '@tests/unit/shared/Stubs/SharedFunctionStub';
 import { FunctionCallStub } from '@tests/unit/shared/Stubs/FunctionCallStub';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
diff --git a/tests/unit/application/Parser/Script/Compiler/Function/SharedFunctionsParser.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/Function/SharedFunctionsParser.spec.ts
similarity index 95%
rename from tests/unit/application/Parser/Script/Compiler/Function/SharedFunctionsParser.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/Function/SharedFunctionsParser.spec.ts
index 73f5862a..b172b2fc 100644
--- a/tests/unit/application/Parser/Script/Compiler/Function/SharedFunctionsParser.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/Function/SharedFunctionsParser.spec.ts
@@ -1,23 +1,23 @@
 import { describe, it, expect } from 'vitest';
 import type { FunctionData, CodeInstruction } from '@/application/collections/';
-import type { ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import { SharedFunctionsParser, type FunctionParameterFactory } from '@/application/Parser/Script/Compiler/Function/SharedFunctionsParser';
+import type { ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
+import { SharedFunctionsParser, type FunctionParameterFactory } from '@/application/Parser/Executable/Script/Compiler/Function/SharedFunctionsParser';
 import { createFunctionDataWithCode, createFunctionDataWithoutCallOrCode } from '@tests/unit/shared/Stubs/FunctionDataStub';
 import { ParameterDefinitionDataStub } from '@tests/unit/shared/Stubs/ParameterDefinitionDataStub';
 import { FunctionCallDataStub } from '@tests/unit/shared/Stubs/FunctionCallDataStub';
 import { itEachAbsentCollectionValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
 import { itIsSingletonFactory } from '@tests/unit/shared/TestCases/SingletonFactoryTests';
 import { CodeValidatorStub } from '@tests/unit/shared/Stubs/CodeValidatorStub';
-import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
-import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
-import { NoDuplicatedLines } from '@/application/Parser/Script/Validation/Rules/NoDuplicatedLines';
+import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
+import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
+import { NoDuplicatedLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines';
 import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { FunctionParameterStub } from '@tests/unit/shared/Stubs/FunctionParameterStub';
 import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
 import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
-import type { FunctionParameterCollectionFactory } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
+import type { FunctionParameterCollectionFactory } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
 import { FunctionParameterCollectionStub } from '@tests/unit/shared/Stubs/FunctionParameterCollectionStub';
 import { expectCallsFunctionBody, expectCodeFunctionBody } from './ExpectFunctionBodyType';
 
diff --git a/tests/unit/application/Parser/Script/Compiler/ParameterNameTestRunner.ts b/tests/unit/application/Parser/Executable/Script/Compiler/ParameterNameTestRunner.ts
similarity index 100%
rename from tests/unit/application/Parser/Script/Compiler/ParameterNameTestRunner.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/ParameterNameTestRunner.ts
diff --git a/tests/unit/application/Parser/Script/Compiler/ScriptCompiler.spec.ts b/tests/unit/application/Parser/Executable/Script/Compiler/ScriptCompiler.spec.ts
similarity index 93%
rename from tests/unit/application/Parser/Script/Compiler/ScriptCompiler.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Compiler/ScriptCompiler.spec.ts
index 5a35b8bb..a0e64a89 100644
--- a/tests/unit/application/Parser/Script/Compiler/ScriptCompiler.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Compiler/ScriptCompiler.spec.ts
@@ -1,27 +1,27 @@
 import { describe, it, expect } from 'vitest';
 import type { FunctionData } from '@/application/collections/';
-import { ScriptCompiler } from '@/application/Parser/Script/Compiler/ScriptCompiler';
-import type { ISharedFunctionsParser } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionsParser';
-import type { FunctionCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler';
+import { ScriptCompiler } from '@/application/Parser/Executable/Script/Compiler/ScriptCompiler';
+import type { ISharedFunctionsParser } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionsParser';
+import type { FunctionCallCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler';
 import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
 import { createFunctionDataWithCode } from '@tests/unit/shared/Stubs/FunctionDataStub';
 import { FunctionCallCompilerStub } from '@tests/unit/shared/Stubs/FunctionCallCompilerStub';
 import { SharedFunctionsParserStub } from '@tests/unit/shared/Stubs/SharedFunctionsParserStub';
 import { SharedFunctionCollectionStub } from '@tests/unit/shared/Stubs/SharedFunctionCollectionStub';
-import { parseFunctionCalls } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCallParser';
+import { parseFunctionCalls } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCallParser';
 import { FunctionCallDataStub } from '@tests/unit/shared/Stubs/FunctionCallDataStub';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
-import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
+import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
 import { CodeValidatorStub } from '@tests/unit/shared/Stubs/CodeValidatorStub';
-import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
+import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
 import { CompiledCodeStub } from '@tests/unit/shared/Stubs/CompiledCodeStub';
 import { createScriptDataWithCall, createScriptDataWithCode } from '@tests/unit/shared/Stubs/ScriptDataStub';
 import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
 import { ScriptCodeStub } from '@tests/unit/shared/Stubs/ScriptCodeStub';
-import type { ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
+import type { ScriptCodeFactory } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
 import { createScriptCodeFactoryStub } from '@tests/unit/shared/Stubs/ScriptCodeFactoryStub';
-import { itThrowsContextualError } from '../../ContextualErrorTester';
+import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
 
 describe('ScriptCompiler', () => {
   describe('canCompile', () => {
diff --git a/tests/unit/application/Parser/Script/ScriptParser.spec.ts b/tests/unit/application/Parser/Executable/Script/ScriptParser.spec.ts
similarity index 85%
rename from tests/unit/application/Parser/Script/ScriptParser.spec.ts
rename to tests/unit/application/Parser/Executable/Script/ScriptParser.spec.ts
index a0742d7c..49bf9fd3 100644
--- a/tests/unit/application/Parser/Script/ScriptParser.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/ScriptParser.spec.ts
@@ -1,36 +1,35 @@
 import { describe, it, expect } from 'vitest';
 import type { ScriptData } from '@/application/collections/';
-import { parseScript, type ScriptFactory } from '@/application/Parser/Script/ScriptParser';
-import { type DocsParser } from '@/application/Parser/DocumentationParser';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
-import type { ICategoryCollectionParseContext } from '@/application/Parser/Script/ICategoryCollectionParseContext';
+import { parseScript, type ScriptFactory } from '@/application/Parser/Executable/Script/ScriptParser';
+import { type DocsParser } from '@/application/Parser/Executable/DocumentationParser';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
 import { ScriptCompilerStub } from '@tests/unit/shared/Stubs/ScriptCompilerStub';
 import { createScriptDataWithCall, createScriptDataWithCode, createScriptDataWithoutCallOrCodes } from '@tests/unit/shared/Stubs/ScriptDataStub';
 import { EnumParserStub } from '@tests/unit/shared/Stubs/EnumParserStub';
 import { ScriptCodeStub } from '@tests/unit/shared/Stubs/ScriptCodeStub';
-import { CategoryCollectionParseContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionParseContextStub';
+import { CategoryCollectionSpecificUtilitiesStub } from '@tests/unit/shared/Stubs/CategoryCollectionSpecificUtilitiesStub';
 import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
-import { Script } from '@/domain/Script';
 import type { IEnumParser } from '@/application/Common/Enum';
-import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
-import { NoDuplicatedLines } from '@/application/Parser/Script/Validation/Rules/NoDuplicatedLines';
+import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
+import { NoDuplicatedLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines';
 import { CodeValidatorStub } from '@tests/unit/shared/Stubs/CodeValidatorStub';
-import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
+import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
 import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { ErrorWrapperStub } from '@tests/unit/shared/Stubs/ErrorWrapperStub';
-import type { NodeDataValidatorFactory } from '@/application/Parser/NodeValidation/NodeDataValidator';
-import { NodeDataValidatorStub, createNodeDataValidatorFactoryStub } from '@tests/unit/shared/Stubs/NodeDataValidatorStub';
-import { NodeDataType } from '@/application/Parser/NodeValidation/NodeDataType';
-import type { ScriptNodeErrorContext } from '@/application/Parser/NodeValidation/NodeDataErrorContext';
-import type { ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
+import type { ExecutableValidatorFactory } from '@/application/Parser/Executable/Validation/ExecutableValidator';
+import { ExecutableValidatorStub, createExecutableValidatorFactoryStub } from '@tests/unit/shared/Stubs/ExecutableValidatorStub';
+import { ExecutableType } from '@/application/Parser/Executable/Validation/ExecutableType';
+import type { ScriptErrorContext } from '@/application/Parser/Executable/Validation/ExecutableErrorContext';
+import type { ScriptCodeFactory } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
 import { createScriptCodeFactoryStub } from '@tests/unit/shared/Stubs/ScriptCodeFactoryStub';
 import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 import { createScriptFactorySpy } from '@tests/unit/shared/Stubs/ScriptFactoryStub';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-import { itThrowsContextualError } from '../ContextualErrorTester';
-import { itAsserts, itValidatesDefinedData, itValidatesName } from '../NodeDataValidationTester';
-import { generateDataValidationTestScenarios } from '../DataValidationTestScenarioGenerator';
+import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
+import type { CategoryCollectionSpecificUtilities } from '@/application/Parser/Executable/CategoryCollectionSpecificUtilities';
+import { itAsserts, itValidatesDefinedData, itValidatesName } from '../Validation/ExecutableValidationTester';
+import { generateDataValidationTestScenarios } from '../Validation/DataValidationTestScenarioGenerator';
 
 describe('ScriptParser', () => {
   describe('parseScript', () => {
@@ -176,13 +175,13 @@ describe('ScriptParser', () => {
           const script = createScriptDataWithCode();
           const compiler = new ScriptCompilerStub()
             .withCompileAbility(script, expectedCode);
-          const parseContext = new CategoryCollectionParseContextStub()
+          const collectionUtilities = new CategoryCollectionSpecificUtilitiesStub()
             .withCompiler(compiler);
           const { scriptFactorySpy, getInitParameters } = createScriptFactorySpy();
           // act
           const actualScript = new TestContext()
             .withData(script)
-            .withContext(parseContext)
+            .withCollectionUtilities(collectionUtilities)
             .withScriptFactory(scriptFactorySpy)
             .parseScript();
           // assert
@@ -195,14 +194,14 @@ describe('ScriptParser', () => {
           // arrange
           const commentDelimiter = 'should not throw';
           const duplicatedCode = `${commentDelimiter} duplicate-line\n${commentDelimiter} duplicate-line`;
-          const parseContext = new CategoryCollectionParseContextStub()
+          const collectionUtilities = new CategoryCollectionSpecificUtilitiesStub()
             .withSyntax(new LanguageSyntaxStub().withCommentDelimiters(commentDelimiter));
           const script = createScriptDataWithoutCallOrCodes()
             .withCode(duplicatedCode);
           // act
           const act = () => new TestContext()
             .withData(script)
-            .withContext(parseContext);
+            .withCollectionUtilities(collectionUtilities);
           // assert
           expect(act).to.not.throw();
         });
@@ -245,13 +244,13 @@ describe('ScriptParser', () => {
           const script = createScriptDataWithCall();
           const compiler = new ScriptCompilerStub()
             .withCompileAbility(script, new ScriptCodeStub());
-          const parseContext = new CategoryCollectionParseContextStub()
+          const collectionUtilities = new CategoryCollectionSpecificUtilitiesStub()
             .withCompiler(compiler);
           // act
           new TestContext()
             .withData(script)
             .withCodeValidator(validator)
-            .withContext(parseContext)
+            .withCollectionUtilities(collectionUtilities)
             .parseScript();
           // assert
           validator.assertHistory({
@@ -267,9 +266,9 @@ describe('ScriptParser', () => {
         const expectedName = 'expected script name to be validated';
         const script = createScriptDataWithCall()
           .withName(expectedName);
-        const expectedContext: ScriptNodeErrorContext = {
-          type: NodeDataType.Script,
-          selfNode: script,
+        const expectedContext: ScriptErrorContext = {
+          type: ExecutableType.Script,
+          self: script,
         };
         itValidatesName((validatorFactory) => {
           // act
@@ -287,9 +286,9 @@ describe('ScriptParser', () => {
       describe('validates for defined data', () => {
         // arrange
         const expectedScript = createScriptDataWithCall();
-        const expectedContext: ScriptNodeErrorContext = {
-          type: NodeDataType.Script,
-          selfNode: expectedScript,
+        const expectedContext: ScriptErrorContext = {
+          type: ExecutableType.Script,
+          self: expectedScript,
         };
         itValidatesDefinedData(
           (validatorFactory) => {
@@ -374,9 +373,9 @@ describe('ScriptParser', () => {
             itAsserts({
               expectedConditionResult: expectedPass,
               test: (validatorFactory) => {
-                const expectedContext: ScriptNodeErrorContext = {
-                  type: NodeDataType.Script,
-                  selfNode: scriptData,
+                const expectedContext: ScriptErrorContext = {
+                  type: ExecutableType.Script,
+                  self: scriptData,
                 };
                 // act
                 new TestContext()
@@ -400,8 +399,8 @@ describe('ScriptParser', () => {
       const givenData = createScriptDataWithCode();
       const expectedContextMessage = 'Failed to parse script.';
       const expectedError = new Error();
-      const validatorFactory: NodeDataValidatorFactory = () => {
-        const validatorStub = new NodeDataValidatorStub();
+      const validatorFactory: ExecutableValidatorFactory = () => {
+        const validatorStub = new ExecutableValidatorStub();
         validatorStub.createContextualErrorMessage = (message) => message;
         return validatorStub;
       };
@@ -428,7 +427,8 @@ describe('ScriptParser', () => {
 class TestContext {
   private data: ScriptData = createScriptDataWithCode();
 
-  private context: ICategoryCollectionParseContext = new CategoryCollectionParseContextStub();
+  private collectionUtilities
+  : CategoryCollectionSpecificUtilities = new CategoryCollectionSpecificUtilitiesStub();
 
   private levelParser: IEnumParser<RecommendationLevel> = new EnumParserStub<RecommendationLevel>()
     .setupDefaultValue(RecommendationLevel.Standard);
@@ -439,7 +439,7 @@ class TestContext {
 
   private errorWrapper: ErrorWithContextWrapper = new ErrorWrapperStub().get();
 
-  private validatorFactory: NodeDataValidatorFactory = createNodeDataValidatorFactoryStub;
+  private validatorFactory: ExecutableValidatorFactory = createExecutableValidatorFactoryStub;
 
   private docsParser: DocsParser = () => ['docs'];
 
@@ -457,8 +457,10 @@ class TestContext {
     return this;
   }
 
-  public withContext(context: ICategoryCollectionParseContext): this {
-    this.context = context;
+  public withCollectionUtilities(
+    collectionUtilities: CategoryCollectionSpecificUtilities,
+  ): this {
+    this.collectionUtilities = collectionUtilities;
     return this;
   }
 
@@ -472,7 +474,7 @@ class TestContext {
     return this;
   }
 
-  public withValidatorFactory(validatorFactory: NodeDataValidatorFactory): this {
+  public withValidatorFactory(validatorFactory: ExecutableValidatorFactory): this {
     this.validatorFactory = validatorFactory;
     return this;
   }
@@ -492,10 +494,10 @@ class TestContext {
     return this;
   }
 
-  public parseScript(): Script {
+  public parseScript(): ReturnType<typeof parseScript> {
     return parseScript(
       this.data,
-      this.context,
+      this.collectionUtilities,
       {
         levelParser: this.levelParser,
         createScript: this.scriptFactory,
diff --git a/tests/unit/application/Parser/Script/Validation/CodeValidator.spec.ts b/tests/unit/application/Parser/Executable/Script/Validation/CodeValidator.spec.ts
similarity index 95%
rename from tests/unit/application/Parser/Script/Validation/CodeValidator.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Validation/CodeValidator.spec.ts
index 56764995..6fd7c535 100644
--- a/tests/unit/application/Parser/Script/Validation/CodeValidator.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Validation/CodeValidator.spec.ts
@@ -1,10 +1,10 @@
 import { describe, it, expect } from 'vitest';
-import { CodeValidator } from '@/application/Parser/Script/Validation/CodeValidator';
+import { CodeValidator } from '@/application/Parser/Executable/Script/Validation/CodeValidator';
 import { CodeValidationRuleStub } from '@tests/unit/shared/Stubs/CodeValidationRuleStub';
 import { itEachAbsentCollectionValue, itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
 import { itIsSingletonFactory } from '@tests/unit/shared/TestCases/SingletonFactoryTests';
-import type { ICodeLine } from '@/application/Parser/Script/Validation/ICodeLine';
-import type { ICodeValidationRule, IInvalidCodeLine } from '@/application/Parser/Script/Validation/ICodeValidationRule';
+import type { ICodeLine } from '@/application/Parser/Executable/Script/Validation/ICodeLine';
+import type { ICodeValidationRule, IInvalidCodeLine } from '@/application/Parser/Executable/Script/Validation/ICodeValidationRule';
 
 describe('CodeValidator', () => {
   describe('instance', () => {
diff --git a/tests/unit/application/Parser/Script/Validation/Rules/CodeValidationRuleTestRunner.ts b/tests/unit/application/Parser/Executable/Script/Validation/Rules/CodeValidationRuleTestRunner.ts
similarity index 86%
rename from tests/unit/application/Parser/Script/Validation/Rules/CodeValidationRuleTestRunner.ts
rename to tests/unit/application/Parser/Executable/Script/Validation/Rules/CodeValidationRuleTestRunner.ts
index f50024ae..6c163300 100644
--- a/tests/unit/application/Parser/Script/Validation/Rules/CodeValidationRuleTestRunner.ts
+++ b/tests/unit/application/Parser/Executable/Script/Validation/Rules/CodeValidationRuleTestRunner.ts
@@ -1,6 +1,6 @@
 import { it, expect } from 'vitest';
-import type { ICodeValidationRule, IInvalidCodeLine } from '@/application/Parser/Script/Validation/ICodeValidationRule';
-import type { ICodeLine } from '@/application/Parser/Script/Validation/ICodeLine';
+import type { ICodeValidationRule, IInvalidCodeLine } from '@/application/Parser/Executable/Script/Validation/ICodeValidationRule';
+import type { ICodeLine } from '@/application/Parser/Executable/Script/Validation/ICodeLine';
 
 interface ICodeValidationRuleTestCase {
   testName: string;
diff --git a/tests/unit/application/Parser/Script/Validation/Rules/NoDuplicatedLines.spec.ts b/tests/unit/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines.spec.ts
similarity index 93%
rename from tests/unit/application/Parser/Script/Validation/Rules/NoDuplicatedLines.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines.spec.ts
index 827d3ca9..accad9d8 100644
--- a/tests/unit/application/Parser/Script/Validation/Rules/NoDuplicatedLines.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines.spec.ts
@@ -1,7 +1,7 @@
 import { describe } from 'vitest';
-import { NoDuplicatedLines } from '@/application/Parser/Script/Validation/Rules/NoDuplicatedLines';
+import { NoDuplicatedLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines';
 import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
-import type { IInvalidCodeLine } from '@/application/Parser/Script/Validation/ICodeValidationRule';
+import type { IInvalidCodeLine } from '@/application/Parser/Executable/Script/Validation/ICodeValidationRule';
 import { testCodeValidationRule } from './CodeValidationRuleTestRunner';
 
 describe('NoDuplicatedLines', () => {
diff --git a/tests/unit/application/Parser/Script/Validation/Rules/NoEmptyLines.spec.ts b/tests/unit/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines.spec.ts
similarity index 94%
rename from tests/unit/application/Parser/Script/Validation/Rules/NoEmptyLines.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines.spec.ts
index 270cfae9..03e4db7f 100644
--- a/tests/unit/application/Parser/Script/Validation/Rules/NoEmptyLines.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines.spec.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
+import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
 import { testCodeValidationRule } from './CodeValidationRuleTestRunner';
 
 describe('NoEmptyLines', () => {
diff --git a/tests/unit/application/Parser/Script/Validation/Syntax/ConcreteSyntaxes.spec.ts b/tests/unit/application/Parser/Executable/Script/Validation/Syntax/ConcreteSyntaxes.spec.ts
similarity index 69%
rename from tests/unit/application/Parser/Script/Validation/Syntax/ConcreteSyntaxes.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Validation/Syntax/ConcreteSyntaxes.spec.ts
index 3c50a74d..deade41f 100644
--- a/tests/unit/application/Parser/Script/Validation/Syntax/ConcreteSyntaxes.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Validation/Syntax/ConcreteSyntaxes.spec.ts
@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
-import { ShellScriptSyntax } from '@/application/Parser/Script/Validation/Syntax/ShellScriptSyntax';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
-import { BatchFileSyntax } from '@/application/Parser/Script/Validation/Syntax/BatchFileSyntax';
+import { ShellScriptSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ShellScriptSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
+import { BatchFileSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/BatchFileSyntax';
 
 function getSystemsUnderTest(): ILanguageSyntax[] {
   return [new BatchFileSyntax(), new ShellScriptSyntax()];
diff --git a/tests/unit/application/Parser/Script/Validation/Syntax/SyntaxFactory.spec.ts b/tests/unit/application/Parser/Executable/Script/Validation/Syntax/SyntaxFactory.spec.ts
similarity index 62%
rename from tests/unit/application/Parser/Script/Validation/Syntax/SyntaxFactory.spec.ts
rename to tests/unit/application/Parser/Executable/Script/Validation/Syntax/SyntaxFactory.spec.ts
index f78e26ff..35a4b47d 100644
--- a/tests/unit/application/Parser/Script/Validation/Syntax/SyntaxFactory.spec.ts
+++ b/tests/unit/application/Parser/Executable/Script/Validation/Syntax/SyntaxFactory.spec.ts
@@ -1,9 +1,9 @@
 import { describe } from 'vitest';
-import { SyntaxFactory } from '@/application/Parser/Script/Validation/Syntax/SyntaxFactory';
+import { SyntaxFactory } from '@/application/Parser/Executable/Script/Validation/Syntax/SyntaxFactory';
 import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
-import { ShellScriptSyntax } from '@/application/Parser/Script/Validation/Syntax/ShellScriptSyntax';
+import { ShellScriptSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ShellScriptSyntax';
 import { ScriptingLanguageFactoryTestRunner } from '@tests/unit/application/Common/ScriptingLanguage/ScriptingLanguageFactoryTestRunner';
-import { BatchFileSyntax } from '@/application/Parser/Script/Validation/Syntax/BatchFileSyntax';
+import { BatchFileSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/BatchFileSyntax';
 
 describe('SyntaxFactory', () => {
   const sut = new SyntaxFactory();
diff --git a/tests/unit/application/Parser/DataValidationTestScenarioGenerator.ts b/tests/unit/application/Parser/Executable/Validation/DataValidationTestScenarioGenerator.ts
similarity index 100%
rename from tests/unit/application/Parser/DataValidationTestScenarioGenerator.ts
rename to tests/unit/application/Parser/Executable/Validation/DataValidationTestScenarioGenerator.ts
diff --git a/tests/unit/application/Parser/NodeDataValidationTester.ts b/tests/unit/application/Parser/Executable/Validation/ExecutableValidationTester.ts
similarity index 71%
rename from tests/unit/application/Parser/NodeDataValidationTester.ts
rename to tests/unit/application/Parser/Executable/Validation/ExecutableValidationTester.ts
index f6836b98..df98f1cc 100644
--- a/tests/unit/application/Parser/NodeDataValidationTester.ts
+++ b/tests/unit/application/Parser/Executable/Validation/ExecutableValidationTester.ts
@@ -1,29 +1,29 @@
 import { it } from 'vitest';
-import type { NodeDataValidator, NodeDataValidatorFactory } from '@/application/Parser/NodeValidation/NodeDataValidator';
-import type { NodeDataErrorContext } from '@/application/Parser/NodeValidation/NodeDataErrorContext';
-import { NodeDataValidatorStub } from '@tests/unit/shared/Stubs/NodeDataValidatorStub';
+import type { ExecutableValidator, ExecutableValidatorFactory } from '@/application/Parser/Executable/Validation/ExecutableValidator';
+import type { ExecutableErrorContext } from '@/application/Parser/Executable/Validation/ExecutableErrorContext';
+import { ExecutableValidatorStub } from '@tests/unit/shared/Stubs/ExecutableValidatorStub';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-import type { CategoryOrScriptData } from '@/application/collections/';
+import type { ExecutableData } from '@/application/collections/';
 import type { FunctionKeys } from '@/TypeHelpers';
 import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
 import { indentText } from '@tests/shared/Text';
 
-type NodeValidationTestFunction<TExpectation> = (
-  factory: NodeDataValidatorFactory,
+type ValidationTestFunction<TExpectation> = (
+  factory: ExecutableValidatorFactory,
 ) => TExpectation;
 
 interface ValidNameExpectation {
   readonly expectedNameToValidate: string;
-  readonly expectedErrorContext: NodeDataErrorContext;
+  readonly expectedErrorContext: ExecutableErrorContext;
 }
 
 export function itValidatesName(
-  test: NodeValidationTestFunction<ValidNameExpectation>,
+  test: ValidationTestFunction<ValidNameExpectation>,
 ) {
   it('validates for name', () => {
     // arrange
-    const validator = new NodeDataValidatorStub();
-    const factoryStub: NodeDataValidatorFactory = () => validator;
+    const validator = new ExecutableValidatorStub();
+    const factoryStub: ExecutableValidatorFactory = () => validator;
     // act
     test(factoryStub);
     // assert
@@ -32,8 +32,8 @@ export function itValidatesName(
   });
   it('validates for name with correct name', () => {
     // arrange
-    const validator = new NodeDataValidatorStub();
-    const factoryStub: NodeDataValidatorFactory = () => validator;
+    const validator = new ExecutableValidatorStub();
+    const factoryStub: ExecutableValidatorFactory = () => validator;
     // act
     const expectation = test(factoryStub);
     // assert
@@ -53,17 +53,17 @@ export function itValidatesName(
 }
 
 interface ValidDataExpectation {
-  readonly expectedDataToValidate: CategoryOrScriptData;
-  readonly expectedErrorContext: NodeDataErrorContext;
+  readonly expectedDataToValidate: ExecutableData;
+  readonly expectedErrorContext: ExecutableErrorContext;
 }
 
 export function itValidatesDefinedData(
-  test: NodeValidationTestFunction<ValidDataExpectation>,
+  test: ValidationTestFunction<ValidDataExpectation>,
 ) {
   it('validates data', () => {
     // arrange
-    const validator = new NodeDataValidatorStub();
-    const factoryStub: NodeDataValidatorFactory = () => validator;
+    const validator = new ExecutableValidatorStub();
+    const factoryStub: ExecutableValidatorFactory = () => validator;
     // act
     test(factoryStub);
     // assert
@@ -72,8 +72,8 @@ export function itValidatesDefinedData(
   });
   it('validates data with correct data', () => {
     // arrange
-    const validator = new NodeDataValidatorStub();
-    const factoryStub: NodeDataValidatorFactory = () => validator;
+    const validator = new ExecutableValidatorStub();
+    const factoryStub: ExecutableValidatorFactory = () => validator;
     // act
     const expectation = test(factoryStub);
     // assert
@@ -93,20 +93,20 @@ export function itValidatesDefinedData(
 
 interface AssertionExpectation {
   readonly expectedErrorMessage: string;
-  readonly expectedErrorContext: NodeDataErrorContext;
+  readonly expectedErrorContext: ExecutableErrorContext;
 }
 
 export function itAsserts(
   testScenario: {
-    readonly test: NodeValidationTestFunction<AssertionExpectation>,
+    readonly test: ValidationTestFunction<AssertionExpectation>,
     readonly expectedConditionResult: boolean;
   },
 ) {
   it('asserts with correct message', () => {
     // arrange
-    const validator = new NodeDataValidatorStub()
+    const validator = new ExecutableValidatorStub()
       .withAssertThrowsOnFalseCondition(false);
-    const factoryStub: NodeDataValidatorFactory = () => validator;
+    const factoryStub: ExecutableValidatorFactory = () => validator;
     // act
     const expectation = testScenario.test(factoryStub);
     // assert
@@ -116,7 +116,12 @@ export function itAsserts(
       const [, message] = call.args;
       return message;
     });
-    expect(actualMessages).to.include(expectedError);
+    expect(actualMessages).to.include(expectedError, formatAssertionMessage([
+      'Assertion failed: The expected error message was not triggered.',
+      `Expected: "${expectedError}"`,
+      'Actual messages (none match expected):',
+      indentText(actualMessages.map((message) => `- ${message}`).join('\n')),
+    ]));
   });
   it('asserts with correct context', () => {
     expectCorrectContextForFunctionCall({
@@ -128,9 +133,9 @@ export function itAsserts(
   it('asserts with correct condition result', () => {
     // arrange
     const expectedEvaluationResult = testScenario.expectedConditionResult;
-    const validator = new NodeDataValidatorStub()
+    const validator = new ExecutableValidatorStub()
       .withAssertThrowsOnFalseCondition(false);
-    const factoryStub: NodeDataValidatorFactory = () => validator;
+    const factoryStub: ExecutableValidatorFactory = () => validator;
     // act
     const expectation = testScenario.test(factoryStub);
     // assert
@@ -154,18 +159,18 @@ export function itAsserts(
 }
 
 function expectCorrectContextForFunctionCall<T>(testScenario: {
-  methodName: FunctionKeys<NodeDataValidator>,
-  act: NodeValidationTestFunction<T>,
-  expectContext: (actionResult: T) => NodeDataErrorContext,
+  methodName: FunctionKeys<ExecutableValidator>,
+  act: ValidationTestFunction<T>,
+  expectContext: (actionResult: T) => ExecutableErrorContext,
 }) {
   // arrange
   const { methodName } = testScenario;
   const createdValidators = new Array<{
-    readonly validator: NodeDataValidatorStub;
-    readonly context: NodeDataErrorContext;
+    readonly validator: ExecutableValidatorStub;
+    readonly context: ExecutableErrorContext;
   }>();
-  const factoryStub: NodeDataValidatorFactory = (context) => {
-    const validator = new NodeDataValidatorStub()
+  const factoryStub: ExecutableValidatorFactory = (context) => {
+    const validator = new ExecutableValidatorStub()
       .withAssertThrowsOnFalseCondition(false);
     createdValidators.push(({
       validator,
diff --git a/tests/unit/application/Parser/NodeValidation/NodeDataValidator.spec.ts b/tests/unit/application/Parser/Executable/Validation/ExecutableValidator.spec.ts
similarity index 65%
rename from tests/unit/application/Parser/NodeValidation/NodeDataValidator.spec.ts
rename to tests/unit/application/Parser/Executable/Validation/ExecutableValidator.spec.ts
index 29357e75..68660889 100644
--- a/tests/unit/application/Parser/NodeValidation/NodeDataValidator.spec.ts
+++ b/tests/unit/application/Parser/Executable/Validation/ExecutableValidator.spec.ts
@@ -1,25 +1,25 @@
 import { describe, it, expect } from 'vitest';
 import { CategoryDataStub } from '@tests/unit/shared/Stubs/CategoryDataStub';
-import type { NodeData } from '@/application/Parser/NodeValidation/NodeData';
-import { createNodeDataErrorContextStub } from '@tests/unit/shared/Stubs/NodeDataErrorContextStub';
-import type { NodeDataErrorContext } from '@/application/Parser/NodeValidation/NodeDataErrorContext';
+import type { ExecutableData } from '@/application/collections/';
+import { createExecutableErrorContextStub } from '@tests/unit/shared/Stubs/ExecutableErrorContextStub';
+import type { ExecutableErrorContext } from '@/application/Parser/Executable/Validation/ExecutableErrorContext';
 import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
-import { ContextualNodeDataValidator, createNodeDataValidator, type NodeDataValidator } from '@/application/Parser/NodeValidation/NodeDataValidator';
-import type { NodeContextErrorMessageCreator } from '@/application/Parser/NodeValidation/NodeDataErrorContextMessage';
+import { ContextualExecutableValidator, createExecutableDataValidator, type ExecutableValidator } from '@/application/Parser/Executable/Validation/ExecutableValidator';
+import type { ExecutableContextErrorMessageCreator } from '@/application/Parser/Executable/Validation/ExecutableErrorContextMessage';
 import { getAbsentObjectTestCases, getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
 
-describe('createNodeDataValidator', () => {
-  it(`returns an instance of ${ContextualNodeDataValidator.name}`, () => {
+describe('createExecutableDataValidator', () => {
+  it(`returns an instance of ${ContextualExecutableValidator.name}`, () => {
     // arrange
-    const context = createNodeDataErrorContextStub();
+    const context = createExecutableErrorContextStub();
     // act
-    const validator = createNodeDataValidator(context);
+    const validator = createExecutableDataValidator(context);
     // assert
-    expect(validator).to.be.instanceOf(ContextualNodeDataValidator);
+    expect(validator).to.be.instanceOf(ContextualExecutableValidator);
   });
 });
 
-describe('NodeDataValidator', () => {
+describe('ContextualExecutableValidator', () => {
   describe('assertValidName', () => {
     describe('throws when name is invalid', () => {
       // arrange
@@ -55,7 +55,7 @@ describe('NodeDataValidator', () => {
     it('does not throw when name is valid', () => {
       // arrange
       const validName = 'validName';
-      const sut = new NodeValidatorBuilder()
+      const sut = new ValidatorBuilder()
         .build();
       // act
       const act = () => sut.assertValidName(validName);
@@ -64,7 +64,7 @@ describe('NodeDataValidator', () => {
     });
   });
   describe('assertDefined', () => {
-    describe('throws when node data is missing', () => {
+    describe('throws when data is missing', () => {
       // arrange
       const testScenarios: readonly {
         readonly description: string;
@@ -81,11 +81,11 @@ describe('NodeDataValidator', () => {
       ];
       testScenarios.forEach(({ description, invalidData }) => {
         describe(`given "${description}"`, () => {
-          const expectedMessage = 'missing node data';
+          const expectedMessage = 'missing executable data';
           itThrowsCorrectly({
             // act
-            throwingAction: (sut: NodeDataValidator) => {
-              sut.assertDefined(invalidData as NodeData);
+            throwingAction: (sut: ExecutableValidator) => {
+              sut.assertDefined(invalidData as ExecutableData);
             },
             // assert
             expectedMessage,
@@ -93,13 +93,13 @@ describe('NodeDataValidator', () => {
         });
       });
     });
-    it('does not throw if node data is defined', () => {
+    it('does not throw if data is defined', () => {
       // arrange
-      const definedNode = new CategoryDataStub();
-      const sut = new NodeValidatorBuilder()
+      const data = new CategoryDataStub();
+      const sut = new ValidatorBuilder()
         .build();
       // act
-      const act = () => sut.assertDefined(definedNode);
+      const act = () => sut.assertDefined(data);
       // assert
       expect(act).to.not.throw();
     });
@@ -111,7 +111,7 @@ describe('NodeDataValidator', () => {
       // assert
       itThrowsCorrectly({
         // act
-        throwingAction: (sut: NodeDataValidator) => {
+        throwingAction: (sut: ExecutableValidator) => {
           sut.assert(falsePredicate, expectedErrorMessage);
         },
         // assert
@@ -121,7 +121,7 @@ describe('NodeDataValidator', () => {
     it('does not throw if validation succeeds', () => {
       // arrange
       const truePredicate = () => true;
-      const sut = new NodeValidatorBuilder()
+      const sut = new ValidatorBuilder()
         .build();
       // act
       const act = () => sut.assert(truePredicate, 'ignored error');
@@ -133,8 +133,8 @@ describe('NodeDataValidator', () => {
     it('creates using the correct error message', () => {
       // arrange
       const expectedErrorMessage = 'expected error';
-      const errorMessageBuilder: NodeContextErrorMessageCreator = (message) => message;
-      const sut = new NodeValidatorBuilder()
+      const errorMessageBuilder: ExecutableContextErrorMessageCreator = (message) => message;
+      const sut = new ValidatorBuilder()
         .withErrorMessageCreator(errorMessageBuilder)
         .build();
       // act
@@ -144,13 +144,13 @@ describe('NodeDataValidator', () => {
     });
     it('creates using the correct context', () => {
       // arrange
-      const expectedContext = createNodeDataErrorContextStub();
-      let actualContext: NodeDataErrorContext | undefined;
-      const errorMessageBuilder: NodeContextErrorMessageCreator = (_, context) => {
+      const expectedContext = createExecutableErrorContextStub();
+      let actualContext: ExecutableErrorContext | undefined;
+      const errorMessageBuilder: ExecutableContextErrorMessageCreator = (_, context) => {
         actualContext = context;
         return '';
       };
-      const sut = new NodeValidatorBuilder()
+      const sut = new ValidatorBuilder()
         .withContext(expectedContext)
         .withErrorMessageCreator(errorMessageBuilder)
         .build();
@@ -163,7 +163,7 @@ describe('NodeDataValidator', () => {
 });
 
 type ValidationThrowingFunction = (
-  sut: ContextualNodeDataValidator,
+  sut: ContextualExecutableValidator,
 ) => void;
 
 interface ValidationThrowingTestScenario {
@@ -177,8 +177,8 @@ function itThrowsCorrectly(
   it('throws an error', () => {
     // arrange
     const expectedErrorMessage = 'Injected error message';
-    const errorMessageBuilder: NodeContextErrorMessageCreator = () => expectedErrorMessage;
-    const sut = new NodeValidatorBuilder()
+    const errorMessageBuilder: ExecutableContextErrorMessageCreator = () => expectedErrorMessage;
+    const sut = new ValidatorBuilder()
       .withErrorMessageCreator(errorMessageBuilder)
       .build();
     // act
@@ -189,8 +189,8 @@ function itThrowsCorrectly(
   it('throws with the correct error message', () => {
     // arrange
     const expectedErrorMessage = testScenario.expectedMessage;
-    const errorMessageBuilder: NodeContextErrorMessageCreator = (message) => message;
-    const sut = new NodeValidatorBuilder()
+    const errorMessageBuilder: ExecutableContextErrorMessageCreator = (message) => message;
+    const sut = new ValidatorBuilder()
       .withErrorMessageCreator(errorMessageBuilder)
       .build();
     // act
@@ -201,11 +201,11 @@ function itThrowsCorrectly(
   });
   it('throws with the correct context', () => {
     // arrange
-    const expectedContext = createNodeDataErrorContextStub();
-    const serializeContext = (context: NodeDataErrorContext) => JSON.stringify(context);
+    const expectedContext = createExecutableErrorContextStub();
+    const serializeContext = (context: ExecutableErrorContext) => JSON.stringify(context);
     const errorMessageBuilder:
-    NodeContextErrorMessageCreator = (_, context) => serializeContext(context);
-    const sut = new NodeValidatorBuilder()
+    ExecutableContextErrorMessageCreator = (_, context) => serializeContext(context);
+    const sut = new ValidatorBuilder()
       .withContext(expectedContext)
       .withErrorMessageCreator(errorMessageBuilder)
       .build();
@@ -218,23 +218,23 @@ function itThrowsCorrectly(
   });
 }
 
-class NodeValidatorBuilder {
-  private errorContext: NodeDataErrorContext = createNodeDataErrorContextStub();
+class ValidatorBuilder {
+  private errorContext: ExecutableErrorContext = createExecutableErrorContextStub();
 
-  private errorMessageCreator: NodeContextErrorMessageCreator = () => `[${NodeValidatorBuilder.name}] stub error message`;
+  private errorMessageCreator: ExecutableContextErrorMessageCreator = () => `[${ValidatorBuilder.name}] stub error message`;
 
-  public withErrorMessageCreator(errorMessageCreator: NodeContextErrorMessageCreator): this {
+  public withErrorMessageCreator(errorMessageCreator: ExecutableContextErrorMessageCreator): this {
     this.errorMessageCreator = errorMessageCreator;
     return this;
   }
 
-  public withContext(errorContext: NodeDataErrorContext): this {
+  public withContext(errorContext: ExecutableErrorContext): this {
     this.errorContext = errorContext;
     return this;
   }
 
-  public build(): ContextualNodeDataValidator {
-    return new ContextualNodeDataValidator(
+  public build(): ContextualExecutableValidator {
+    return new ContextualExecutableValidator(
       this.errorContext,
       this.errorMessageCreator,
     );
diff --git a/tests/unit/application/Parser/Script/CategoryCollectionParseContext.spec.ts b/tests/unit/application/Parser/Script/CategoryCollectionParseContext.spec.ts
deleted file mode 100644
index 4a0e030c..00000000
--- a/tests/unit/application/Parser/Script/CategoryCollectionParseContext.spec.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { ISyntaxFactory } from '@/application/Parser/Script/Validation/Syntax/ISyntaxFactory';
-import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
-import { CategoryCollectionParseContext } from '@/application/Parser/Script/CategoryCollectionParseContext';
-import { ScriptCompiler } from '@/application/Parser/Script/Compiler/ScriptCompiler';
-import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
-import { ScriptingDefinitionStub } from '@tests/unit/shared/Stubs/ScriptingDefinitionStub';
-import type { FunctionData } from '@/application/collections/';
-import { itEachAbsentCollectionValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
-import { createFunctionDataWithCode } from '@tests/unit/shared/Stubs/FunctionDataStub';
-
-describe('CategoryCollectionParseContext', () => {
-  describe('ctor', () => {
-    describe('functionsData', () => {
-      describe('can create with absent data', () => {
-        itEachAbsentCollectionValue<FunctionData>((absentValue) => {
-          // arrange
-          const scripting = new ScriptingDefinitionStub();
-          // act
-          const act = () => new CategoryCollectionParseContext(absentValue, scripting);
-          // assert
-          expect(act).to.not.throw();
-        }, { excludeNull: true });
-      });
-    });
-  });
-  describe('compiler', () => {
-    it('constructed as expected', () => {
-      // arrange
-      const functionsData = [createFunctionDataWithCode()];
-      const syntax = new LanguageSyntaxStub();
-      const expected = new ScriptCompiler(functionsData, syntax);
-      const language = ScriptingLanguage.shellscript;
-      const factoryMock = mockFactory(language, syntax);
-      const definition = new ScriptingDefinitionStub()
-        .withLanguage(language);
-      // act
-      const sut = new CategoryCollectionParseContext(functionsData, definition, factoryMock);
-      const actual = sut.compiler;
-      // assert
-      expect(actual).to.deep.equal(expected);
-    });
-  });
-  describe('syntax', () => {
-    it('set from syntax factory', () => {
-      // arrange
-      const language = ScriptingLanguage.shellscript;
-      const expected = new LanguageSyntaxStub();
-      const factoryMock = mockFactory(language, expected);
-      const definition = new ScriptingDefinitionStub()
-        .withLanguage(language);
-      // act
-      const sut = new CategoryCollectionParseContext([], definition, factoryMock);
-      const actual = sut.syntax;
-      // assert
-      expect(actual).to.equal(expected);
-    });
-  });
-});
-
-function mockFactory(expectedLanguage: ScriptingLanguage, result: ILanguageSyntax): ISyntaxFactory {
-  return {
-    create: (language: ScriptingLanguage) => {
-      if (language !== expectedLanguage) {
-        throw new Error('unexpected language');
-      }
-      return result;
-    },
-  };
-}
diff --git a/tests/unit/application/Parser/ScriptingDefinition/CodeSubstituter.spec.ts b/tests/unit/application/Parser/ScriptingDefinition/CodeSubstituter.spec.ts
index 26a32197..337a5b55 100644
--- a/tests/unit/application/Parser/ScriptingDefinition/CodeSubstituter.spec.ts
+++ b/tests/unit/application/Parser/ScriptingDefinition/CodeSubstituter.spec.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { CodeSubstituter } from '@/application/Parser/ScriptingDefinition/CodeSubstituter';
-import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
 import { ProjectDetailsStub } from '@tests/unit/shared/Stubs/ProjectDetailsStub';
 import { ExpressionsCompilerStub } from '@tests/unit/shared/Stubs/ExpressionsCompilerStub';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
diff --git a/tests/unit/domain/CategoryCollection.spec.ts b/tests/unit/domain/CategoryCollection.spec.ts
index 65946b4a..09497d21 100644
--- a/tests/unit/domain/CategoryCollection.spec.ts
+++ b/tests/unit/domain/CategoryCollection.spec.ts
@@ -1,9 +1,9 @@
 import { describe, it, expect } from 'vitest';
-import type { ICategory } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
 import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
 import { getEnumValues } from '@/application/Common/Enum';
 import { CategoryCollection } from '@/domain/CategoryCollection';
 import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
@@ -296,7 +296,7 @@ function getValidScriptingDefinition(): IScriptingDefinition {
 class CategoryCollectionBuilder {
   private os = OperatingSystem.Windows;
 
-  private actions: readonly ICategory[] = [
+  private actions: readonly Category[] = [
     new CategoryStub(1).withMandatoryScripts(),
   ];
 
@@ -307,7 +307,7 @@ class CategoryCollectionBuilder {
     return this;
   }
 
-  public withActions(actions: readonly ICategory[]): this {
+  public withActions(actions: readonly Category[]): this {
     this.actions = actions;
     return this;
   }
diff --git a/tests/unit/domain/Category.spec.ts b/tests/unit/domain/Executables/Category/CollectionCategory.spec.ts
similarity index 90%
rename from tests/unit/domain/Category.spec.ts
rename to tests/unit/domain/Executables/Category/CollectionCategory.spec.ts
index ac09d5bc..1c4268db 100644
--- a/tests/unit/domain/Category.spec.ts
+++ b/tests/unit/domain/Executables/Category/CollectionCategory.spec.ts
@@ -1,11 +1,12 @@
 import { describe, it, expect } from 'vitest';
-import { Category } from '@/domain/Category';
+import { CollectionCategory } from '@/domain/Executables/Category/CollectionCategory';
 import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
 import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import type { ICategory, IScript } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
+import type { Script } from '@/domain/Executables/Script/Script';
 
-describe('Category', () => {
+describe('CollectionCategory', () => {
   describe('ctor', () => {
     describe('throws error if name is absent', () => {
       itEachAbsentStringValue((absentValue) => {
@@ -23,8 +24,8 @@ describe('Category', () => {
     it('throws error if no children are present', () => {
       // arrange
       const expectedError = 'A category must have at least one sub-category or script';
-      const scriptChildren: readonly IScript[] = [];
-      const categoryChildren: readonly ICategory[] = [];
+      const scriptChildren: readonly Script[] = [];
+      const categoryChildren: readonly Category[] = [];
       // act
       const construct = () => new CategoryBuilder()
         .withSubcategories(categoryChildren)
@@ -173,9 +174,9 @@ class CategoryBuilder {
 
   private docs: ReadonlyArray<string> = [];
 
-  private subcategories: ReadonlyArray<ICategory> = [];
+  private subcategories: ReadonlyArray<Category> = [];
 
-  private scripts: ReadonlyArray<IScript> = [
+  private scripts: ReadonlyArray<Script> = [
     new ScriptStub(`[${CategoryBuilder.name}] script`),
   ];
 
@@ -194,18 +195,18 @@ class CategoryBuilder {
     return this;
   }
 
-  public withScripts(scripts: ReadonlyArray<IScript>): this {
+  public withScripts(scripts: ReadonlyArray<Script>): this {
     this.scripts = scripts;
     return this;
   }
 
-  public withSubcategories(subcategories: ReadonlyArray<ICategory>): this {
+  public withSubcategories(subcategories: ReadonlyArray<Category>): this {
     this.subcategories = subcategories;
     return this;
   }
 
-  public build(): Category {
-    return new Category({
+  public build(): CollectionCategory {
+    return new CollectionCategory({
       id: this.id,
       name: this.name,
       docs: this.docs,
diff --git a/tests/unit/domain/ScriptCode.spec.ts b/tests/unit/domain/Executables/Script/Code/ScriptCode.spec.ts
similarity index 92%
rename from tests/unit/domain/ScriptCode.spec.ts
rename to tests/unit/domain/Executables/Script/Code/ScriptCode.spec.ts
index 4ea2b28c..4d55eb99 100644
--- a/tests/unit/domain/ScriptCode.spec.ts
+++ b/tests/unit/domain/Executables/Script/Code/ScriptCode.spec.ts
@@ -1,8 +1,8 @@
 import { describe, it, expect } from 'vitest';
-import { ScriptCode } from '@/domain/ScriptCode';
+import { DistinctReversibleScriptCode } from '@/domain/Executables/Script/Code/DistinctReversibleScriptCode';
 import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
 
-describe('ScriptCode', () => {
+describe('DistinctReversibleScriptCode', () => {
   describe('code', () => {
     describe('throws with invalid code', () => {
       // arrange
@@ -96,8 +96,8 @@ class ScriptCodeBuilder {
     return this;
   }
 
-  public build(): ScriptCode {
-    return new ScriptCode(
+  public build(): DistinctReversibleScriptCode {
+    return new DistinctReversibleScriptCode(
       this.execute,
       this.revert,
     );
diff --git a/tests/unit/domain/Script.spec.ts b/tests/unit/domain/Executables/Script/CollectionScript.spec.ts
similarity index 88%
rename from tests/unit/domain/Script.spec.ts
rename to tests/unit/domain/Executables/Script/CollectionScript.spec.ts
index 0ae0c049..753aaf3f 100644
--- a/tests/unit/domain/Script.spec.ts
+++ b/tests/unit/domain/Executables/Script/CollectionScript.spec.ts
@@ -1,11 +1,11 @@
 import { describe, it, expect } from 'vitest';
 import { getEnumValues } from '@/application/Common/Enum';
-import { Script } from '@/domain/Script';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
-import type { IScriptCode } from '@/domain/IScriptCode';
+import { CollectionScript } from '@/domain/Executables/Script/CollectionScript';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
 import { ScriptCodeStub } from '@tests/unit/shared/Stubs/ScriptCodeStub';
 
-describe('Script', () => {
+describe('CollectionScript', () => {
   describe('ctor', () => {
     describe('scriptCode', () => {
       it('assigns code correctly', () => {
@@ -96,7 +96,7 @@ describe('Script', () => {
 class ScriptBuilder {
   private name = 'test-script';
 
-  private code: IScriptCode = new ScriptCodeStub();
+  private code: ScriptCode = new ScriptCodeStub();
 
   private level? = RecommendationLevel.Standard;
 
@@ -109,7 +109,7 @@ class ScriptBuilder {
     return this;
   }
 
-  public withCode(code: IScriptCode): this {
+  public withCode(code: ScriptCode): this {
     this.code = code;
     return this;
   }
@@ -129,8 +129,8 @@ class ScriptBuilder {
     return this;
   }
 
-  public build(): Script {
-    return new Script({
+  public build(): CollectionScript {
+    return new CollectionScript({
       name: this.name,
       code: this.code,
       docs: this.docs,
diff --git a/tests/unit/domain/ScriptCodeFactory.spec.ts b/tests/unit/domain/ScriptCodeFactory.spec.ts
index feb1e54b..c1cb9c0f 100644
--- a/tests/unit/domain/ScriptCodeFactory.spec.ts
+++ b/tests/unit/domain/ScriptCodeFactory.spec.ts
@@ -1,4 +1,4 @@
-import { createScriptCode } from '@/domain/ScriptCodeFactory';
+import { createScriptCode } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
 
 describe('ScriptCodeFactory', () => {
   describe('createScriptCode', () => {
diff --git a/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.spec.ts b/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.spec.ts
index 46cb5754..d862d1bf 100644
--- a/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.spec.ts
+++ b/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler.spec.ts
@@ -3,14 +3,14 @@ import {
   type SelectionCheckContext, type SelectionMutationContext,
   getCurrentRecommendationStatus, setCurrentRecommendationStatus,
 } from '@/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusHandler';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
 import type { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
 import { EnumRangeTestRunner } from '@tests/unit/application/Common/EnumRangeTestRunner';
 import type { ScriptSelection } from '@/application/Context/State/Selection/Script/ScriptSelection';
 import type { MethodCall } from '@tests/unit/shared/Stubs/StubWithObservableMethodCalls';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 import { scrambledEqual } from '@/application/Common/Array';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { RecommendationStatusType } from '@/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusType';
 import { RecommendationStatusTestScenario } from './RecommendationStatusTestScenario';
 
@@ -85,8 +85,8 @@ describe('RecommendationStatusHandler', () => {
           expectExists(call);
           if (expectedCall.args.length > 0) { /** {@link ScriptSelection.selectOnly}. */
             expect(scrambledEqual(
-              call.args[0] as IScript[],
-              expectedCall.args[0] as IScript[],
+              call.args[0] as Script[],
+              expectedCall.args[0] as Script[],
             )).to.equal(true);
           }
         });
diff --git a/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusTestScenario.ts b/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusTestScenario.ts
index 85ae976f..c7d2ce12 100644
--- a/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusTestScenario.ts
+++ b/tests/unit/presentation/components/Scripts/Menu/Recommendation/RecommendationStatusTestScenario.ts
@@ -1,5 +1,5 @@
 import type { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
 import { CategoryCollectionStateStub } from '@tests/unit/shared/Stubs/CategoryCollectionStateStub';
 import { ScriptSelectionStub } from '@tests/unit/shared/Stubs/ScriptSelectionStub';
 import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
diff --git a/tests/unit/presentation/components/Scripts/View/Tree/NodeContent/Reverter/CategoryReverter.spec.ts b/tests/unit/presentation/components/Scripts/View/Tree/NodeContent/Reverter/CategoryReverter.spec.ts
index 98c00171..30d52049 100644
--- a/tests/unit/presentation/components/Scripts/View/Tree/NodeContent/Reverter/CategoryReverter.spec.ts
+++ b/tests/unit/presentation/components/Scripts/View/Tree/NodeContent/Reverter/CategoryReverter.spec.ts
@@ -8,15 +8,15 @@ import { UserSelectionStub } from '@tests/unit/shared/Stubs/UserSelectionStub';
 import { SelectedScriptStub } from '@tests/unit/shared/Stubs/SelectedScriptStub';
 import type { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
 import { CategorySelectionStub } from '@tests/unit/shared/Stubs/CategorySelectionStub';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 
 describe('CategoryReverter', () => {
   describe('getState', () => {
     // arrange
     const testScenarios: ReadonlyArray<{
       readonly description: string;
-      readonly allScripts: readonly IScript[];
-      readonly selectScripts: (allScripts: readonly IScript[]) => readonly SelectedScript[];
+      readonly allScripts: readonly Script[];
+      readonly selectScripts: (allScripts: readonly Script[]) => readonly SelectedScript[];
       readonly expectedState: boolean;
     }> = [
       {
diff --git a/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter.spec.ts b/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter.spec.ts
index 1ea61c42..ec789135 100644
--- a/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter.spec.ts
+++ b/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter.spec.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import type { IScript } from '@/domain/IScript';
-import type { ICategory } from '@/domain/ICategory';
+import type { Script } from '@/domain/Executables/Script/Script';
+import type { Category } from '@/domain/Executables/Category/Category';
 import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
 import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
@@ -8,7 +8,7 @@ import {
   getCategoryId, getCategoryNodeId, getScriptId,
   getScriptNodeId, parseAllCategories, parseSingleCategory,
 } from '@/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter';
-import { NodeDataType } from '@/application/Parser/NodeValidation/NodeDataType';
+import { ExecutableType } from '@/application/Parser/Executable/Validation/ExecutableType';
 import type { NodeMetadata } from '@/presentation/components/Scripts/View/Tree/NodeContent/NodeMetadata';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 
@@ -94,7 +94,7 @@ describe('CategoryNodeMetadataConverter', () => {
   });
 });
 
-function isReversible(category: ICategory): boolean {
+function isReversible(category: Category): boolean {
   if (category.scripts) {
     if (category.scripts.some((s) => !s.canRevert())) {
       return false;
@@ -108,8 +108,8 @@ function isReversible(category: ICategory): boolean {
   return true;
 }
 
-function expectSameCategory(node: NodeMetadata, category: ICategory): void {
-  expect(node.type).to.equal(NodeDataType.Category, getErrorMessage('type'));
+function expectSameCategory(node: NodeMetadata, category: Category): void {
+  expect(node.type).to.equal(ExecutableType.Category, getErrorMessage('type'));
   expect(node.id).to.equal(getCategoryNodeId(category), getErrorMessage('id'));
   expect(node.docs).to.equal(category.docs, getErrorMessage('docs'));
   expect(node.text).to.equal(category.name, getErrorMessage('name'));
@@ -135,8 +135,8 @@ function expectSameCategory(node: NodeMetadata, category: ICategory): void {
   }
 }
 
-function expectSameScript(node: NodeMetadata, script: IScript): void {
-  expect(node.type).to.equal(NodeDataType.Script, getErrorMessage('type'));
+function expectSameScript(node: NodeMetadata, script: Script): void {
+  expect(node.type).to.equal(ExecutableType.Script, getErrorMessage('type'));
   expect(node.id).to.equal(getScriptNodeId(script), getErrorMessage('id'));
   expect(node.docs).to.equal(script.docs, getErrorMessage('docs'));
   expect(node.text).to.equal(script.name, getErrorMessage('name'));
diff --git a/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseSelectedScriptNodeIds.spec.ts b/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseSelectedScriptNodeIds.spec.ts
index ff13a98e..554d1260 100644
--- a/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseSelectedScriptNodeIds.spec.ts
+++ b/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseSelectedScriptNodeIds.spec.ts
@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { useSelectedScriptNodeIds } from '@/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseSelectedScriptNodeIds';
 import { SelectedScriptStub } from '@tests/unit/shared/Stubs/SelectedScriptStub';
 import { getScriptNodeId } from '@/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { UseUserSelectionStateStub } from '@tests/unit/shared/Stubs/UseUserSelectionStateStub';
 import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 
@@ -23,7 +23,7 @@ describe('useSelectedScriptNodeIds', () => {
         new SelectedScriptStub(new ScriptStub('id-1')),
         new SelectedScriptStub(new ScriptStub('id-2')),
       ];
-      const parsedNodeIds = new Map<IScript, string>([
+      const parsedNodeIds = new Map<Script, string>([
         [selectedScripts[0].script, 'expected-id-1'],
         [selectedScripts[1].script, 'expected-id-2'],
       ]);
@@ -47,7 +47,7 @@ describe('useSelectedScriptNodeIds', () => {
         new SelectedScriptStub(new ScriptStub('id-1')),
         new SelectedScriptStub(new ScriptStub('id-2')),
       ];
-      const parsedNodeIds = new Map<IScript, string>([
+      const parsedNodeIds = new Map<Script, string>([
         [changedScripts[0].script, 'expected-id-1'],
         [changedScripts[1].script, 'expected-id-2'],
       ]);
@@ -70,7 +70,7 @@ describe('useSelectedScriptNodeIds', () => {
 
 type ScriptNodeIdParser = typeof getScriptNodeId;
 
-function createNodeIdParserFromMap(scriptToIdMap: Map<IScript, string>): ScriptNodeIdParser {
+function createNodeIdParserFromMap(scriptToIdMap: Map<Script, string>): ScriptNodeIdParser {
   return (script) => {
     const expectedId = scriptToIdMap.get(script);
     if (!expectedId) {
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 461ceb2a..bb7b16d9 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
@@ -11,8 +11,8 @@ import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
 import { TreeNodeStub } from '@tests/unit/shared/Stubs/TreeNodeStub';
 import { HierarchyAccessStub } from '@tests/unit/shared/Stubs/HierarchyAccessStub';
-import type { IScript } from '@/domain/IScript';
-import type { ICategory } from '@/domain/ICategory';
+import type { Script } from '@/domain/Executables/Script/Script';
+import type { Category } from '@/domain/Executables/Category/Category';
 import type { TreeNode } from '@/presentation/components/Scripts/View/Tree/TreeView/Node/TreeNode';
 import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
 import type { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
@@ -208,8 +208,8 @@ function itExpectedFilterTriggeredEvent(
 ) {
   const testScenarios: ReadonlyArray<{
     readonly description: string;
-    readonly scriptMatches: IScript[],
-    readonly categoryMatches: ICategory[],
+    readonly scriptMatches: Script[],
+    readonly categoryMatches: Category[],
     readonly givenNode: TreeNode,
     readonly expectedPredicateResult: boolean;
   }> = [
diff --git a/tests/unit/shared/Stubs/ArgumentCompilerStub.ts b/tests/unit/shared/Stubs/ArgumentCompilerStub.ts
index 98c6c0e5..719b9760 100644
--- a/tests/unit/shared/Stubs/ArgumentCompilerStub.ts
+++ b/tests/unit/shared/Stubs/ArgumentCompilerStub.ts
@@ -1,6 +1,6 @@
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import type { ArgumentCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { ArgumentCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import { FunctionCallStub } from './FunctionCallStub';
 import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 
diff --git a/tests/unit/shared/Stubs/CategoryCollectionParseContextStub.ts b/tests/unit/shared/Stubs/CategoryCollectionParseContextStub.ts
deleted file mode 100644
index a95bd0ae..00000000
--- a/tests/unit/shared/Stubs/CategoryCollectionParseContextStub.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import type { ICategoryCollectionParseContext } from '@/application/Parser/Script/ICategoryCollectionParseContext';
-import type { IScriptCompiler } from '@/application/Parser/Script/Compiler/IScriptCompiler';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
-import { ScriptCompilerStub } from './ScriptCompilerStub';
-import { LanguageSyntaxStub } from './LanguageSyntaxStub';
-
-export class CategoryCollectionParseContextStub implements ICategoryCollectionParseContext {
-  public compiler: IScriptCompiler = new ScriptCompilerStub();
-
-  public syntax: ILanguageSyntax = new LanguageSyntaxStub();
-
-  public withCompiler(compiler: IScriptCompiler) {
-    this.compiler = compiler;
-    return this;
-  }
-
-  public withSyntax(syntax: ILanguageSyntax) {
-    this.syntax = syntax;
-    return this;
-  }
-}
diff --git a/tests/unit/shared/Stubs/CategoryCollectionSpecificUtilitiesStub.ts b/tests/unit/shared/Stubs/CategoryCollectionSpecificUtilitiesStub.ts
new file mode 100644
index 00000000..cb41e251
--- /dev/null
+++ b/tests/unit/shared/Stubs/CategoryCollectionSpecificUtilitiesStub.ts
@@ -0,0 +1,22 @@
+import type { IScriptCompiler } from '@/application/Parser/Executable/Script/Compiler/IScriptCompiler';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
+import type { CategoryCollectionSpecificUtilities } from '@/application/Parser/Executable/CategoryCollectionSpecificUtilities';
+import { ScriptCompilerStub } from './ScriptCompilerStub';
+import { LanguageSyntaxStub } from './LanguageSyntaxStub';
+
+export class CategoryCollectionSpecificUtilitiesStub
+implements CategoryCollectionSpecificUtilities {
+  public compiler: IScriptCompiler = new ScriptCompilerStub();
+
+  public syntax: ILanguageSyntax = new LanguageSyntaxStub();
+
+  public withCompiler(compiler: IScriptCompiler) {
+    this.compiler = compiler;
+    return this;
+  }
+
+  public withSyntax(syntax: ILanguageSyntax) {
+    this.syntax = syntax;
+    return this;
+  }
+}
diff --git a/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts b/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts
index 232226b6..fc8cc4e6 100644
--- a/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts
+++ b/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts
@@ -1,7 +1,7 @@
 import type { IApplicationCode } from '@/application/Context/State/Code/IApplicationCode';
 import type { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
 import { OperatingSystem } from '@/domain/OperatingSystem';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
 import type { UserSelection } from '@/application/Context/State/Selection/UserSelection';
@@ -27,7 +27,7 @@ export class CategoryCollectionStateStub implements ICategoryCollectionState {
 
   public selection: UserSelection = new UserSelectionStub();
 
-  constructor(readonly allScripts: IScript[] = [new ScriptStub('script-id')]) {
+  constructor(readonly allScripts: Script[] = [new ScriptStub('script-id')]) {
     this.selection = new UserSelectionStub()
       .withScripts(new ScriptSelectionStub());
     this.collection = new CategoryCollectionStub()
diff --git a/tests/unit/shared/Stubs/CategoryCollectionStub.ts b/tests/unit/shared/Stubs/CategoryCollectionStub.ts
index 310ec6e2..548d79e8 100644
--- a/tests/unit/shared/Stubs/CategoryCollectionStub.ts
+++ b/tests/unit/shared/Stubs/CategoryCollectionStub.ts
@@ -1,9 +1,9 @@
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
-import type { IScript } from '@/domain/IScript';
-import type { ICategory } from '@/domain/ICategory';
+import type { Script } from '@/domain/Executables/Script/Script';
+import type { Category } from '@/domain/Executables/Category/Category';
 import type { ICategoryCollection } from '@/domain/ICategoryCollection';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
 import { ScriptStub } from './ScriptStub';
 import { ScriptingDefinitionStub } from './ScriptingDefinitionStub';
 import { CategoryStub } from './CategoryStub';
@@ -13,13 +13,13 @@ export class CategoryCollectionStub implements ICategoryCollection {
 
   public os = OperatingSystem.Linux;
 
-  public initialScript: IScript = new ScriptStub('55');
+  public initialScript: Script = new ScriptStub('55');
 
   public totalScripts = 0;
 
   public totalCategories = 0;
 
-  public readonly actions = new Array<ICategory>();
+  public readonly actions = new Array<Category>();
 
   public withSomeActions(): this {
     this.withAction(new CategoryStub(1));
@@ -28,12 +28,12 @@ export class CategoryCollectionStub implements ICategoryCollection {
     return this;
   }
 
-  public withAction(category: ICategory): this {
+  public withAction(category: Category): this {
     this.actions.push(category);
     return this;
   }
 
-  public withActions(...actions: readonly ICategory[]): this {
+  public withActions(...actions: readonly Category[]): this {
     for (const action of actions) {
       this.withAction(action);
     }
@@ -50,7 +50,7 @@ export class CategoryCollectionStub implements ICategoryCollection {
     return this;
   }
 
-  public withInitialScript(script: IScript): this {
+  public withInitialScript(script: Script): this {
     this.initialScript = script;
     return this;
   }
@@ -60,41 +60,41 @@ export class CategoryCollectionStub implements ICategoryCollection {
     return this;
   }
 
-  public getCategory(categoryId: number): ICategory {
+  public getCategory(categoryId: number): Category {
     return this.getAllCategories()
       .find((category) => category.id === categoryId)
       ?? new CategoryStub(categoryId);
   }
 
-  public getScriptsByLevel(level: RecommendationLevel): readonly IScript[] {
+  public getScriptsByLevel(level: RecommendationLevel): readonly Script[] {
     return this.getAllScripts()
       .filter((script) => script.level !== undefined && script.level <= level);
   }
 
-  public getScript(scriptId: string): IScript {
+  public getScript(scriptId: string): Script {
     return this.getAllScripts()
       .find((script) => scriptId === script.id)
       ?? new ScriptStub(scriptId);
   }
 
-  public getAllScripts(): ReadonlyArray<IScript> {
+  public getAllScripts(): ReadonlyArray<Script> {
     return this.actions.flatMap((category) => getScriptsRecursively(category));
   }
 
-  public getAllCategories(): ReadonlyArray<ICategory> {
+  public getAllCategories(): ReadonlyArray<Category> {
     return this.actions.flatMap(
       (category) => [category, ...getSubCategoriesRecursively(category)],
     );
   }
 }
 
-function getSubCategoriesRecursively(category: ICategory): ReadonlyArray<ICategory> {
+function getSubCategoriesRecursively(category: Category): ReadonlyArray<Category> {
   return (category.subCategories || []).flatMap(
     (subCategory) => [subCategory, ...getSubCategoriesRecursively(subCategory)],
   );
 }
 
-function getScriptsRecursively(category: ICategory): ReadonlyArray<IScript> {
+function getScriptsRecursively(category: Category): ReadonlyArray<Script> {
   return [
     ...(category.scripts || []),
     ...(category.subCategories || []).flatMap(
diff --git a/tests/unit/shared/Stubs/CategoryDataStub.ts b/tests/unit/shared/Stubs/CategoryDataStub.ts
index bb813483..1535568d 100644
--- a/tests/unit/shared/Stubs/CategoryDataStub.ts
+++ b/tests/unit/shared/Stubs/CategoryDataStub.ts
@@ -1,14 +1,14 @@
-import type { CategoryData, CategoryOrScriptData, DocumentationData } from '@/application/collections/';
+import type { CategoryData, ExecutableData, DocumentationData } from '@/application/collections/';
 import { createScriptDataWithCode } from '@tests/unit/shared/Stubs/ScriptDataStub';
 
 export class CategoryDataStub implements CategoryData {
-  public children: readonly CategoryOrScriptData[] = [createScriptDataWithCode()];
+  public children: readonly ExecutableData[] = [createScriptDataWithCode()];
 
   public category = 'category name';
 
   public docs?: DocumentationData;
 
-  public withChildren(children: readonly CategoryOrScriptData[]) {
+  public withChildren(children: readonly ExecutableData[]) {
     this.children = children;
     return this;
   }
diff --git a/tests/unit/shared/Stubs/CategoryFactoryStub.ts b/tests/unit/shared/Stubs/CategoryFactoryStub.ts
index 2fb0d878..010de32f 100644
--- a/tests/unit/shared/Stubs/CategoryFactoryStub.ts
+++ b/tests/unit/shared/Stubs/CategoryFactoryStub.ts
@@ -1,13 +1,13 @@
-import type { CategoryFactory } from '@/application/Parser/CategoryParser';
-import type { CategoryInitParameters } from '@/domain/Category';
-import type { ICategory } from '@/domain/ICategory';
+import type { CategoryFactory } from '@/application/Parser/Executable/CategoryParser';
+import type { CategoryInitParameters } from '@/domain/Executables/Category/CollectionCategory';
+import type { Category } from '@/domain/Executables/Category/Category';
 import { CategoryStub } from './CategoryStub';
 
 export function createCategoryFactorySpy(): {
   readonly categoryFactorySpy: CategoryFactory;
-  getInitParameters: (category: ICategory) => CategoryInitParameters | undefined;
+  getInitParameters: (category: Category) => CategoryInitParameters | undefined;
 } {
-  const createdCategories = new Map<ICategory, CategoryInitParameters>();
+  const createdCategories = new Map<Category, CategoryInitParameters>();
   return {
     categoryFactorySpy: (parameters) => {
       const category = new CategoryStub(55);
diff --git a/tests/unit/shared/Stubs/CategoryStub.ts b/tests/unit/shared/Stubs/CategoryStub.ts
index 9aab6a87..fe67c92c 100644
--- a/tests/unit/shared/Stubs/CategoryStub.ts
+++ b/tests/unit/shared/Stubs/CategoryStub.ts
@@ -1,28 +1,29 @@
 import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
-import type { ICategory, IScript } from '@/domain/ICategory';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import type { Category } from '@/domain/Executables/Category/Category';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { ScriptStub } from './ScriptStub';
 
-export class CategoryStub extends BaseEntity<number> implements ICategory {
+export class CategoryStub extends BaseEntity<number> implements Category {
   public name = `category-with-id-${this.id}`;
 
-  public readonly subCategories = new Array<ICategory>();
+  public readonly subCategories = new Array<Category>();
 
-  public readonly scripts = new Array<IScript>();
+  public readonly scripts = new Array<Script>();
 
   public docs: readonly string[] = new Array<string>();
 
-  private allScriptsRecursively: (readonly IScript[]) | undefined;
+  private allScriptsRecursively: (readonly Script[]) | undefined;
 
   public constructor(id: number) {
     super(id);
   }
 
-  public includes(script: IScript): boolean {
+  public includes(script: Script): boolean {
     return this.getAllScriptsRecursively().some((s) => s.id === script.id);
   }
 
-  public getAllScriptsRecursively(): readonly IScript[] {
+  public getAllScriptsRecursively(): readonly Script[] {
     if (this.allScriptsRecursively === undefined) {
       return [
         ...this.scripts,
@@ -38,7 +39,7 @@ export class CategoryStub extends BaseEntity<number> implements ICategory {
     );
   }
 
-  public withScripts(...scripts: IScript[]): this {
+  public withScripts(...scripts: Script[]): this {
     for (const script of scripts) {
       this.withScript(script);
     }
@@ -49,7 +50,7 @@ export class CategoryStub extends BaseEntity<number> implements ICategory {
     return this.withAllScriptsRecursively(...scriptIds.map((id) => new ScriptStub(id)));
   }
 
-  public withAllScriptsRecursively(...scripts: IScript[]): this {
+  public withAllScriptsRecursively(...scripts: Script[]): this {
     this.allScriptsRecursively = [...scripts];
     return this;
   }
@@ -61,19 +62,19 @@ export class CategoryStub extends BaseEntity<number> implements ICategory {
       .withScript(new ScriptStub(`[${CategoryStub.name}] script-3`).withLevel(undefined));
   }
 
-  public withCategories(...categories: ICategory[]): this {
+  public withCategories(...categories: Category[]): this {
     for (const category of categories) {
       this.withCategory(category);
     }
     return this;
   }
 
-  public withCategory(category: ICategory): this {
+  public withCategory(category: Category): this {
     this.subCategories.push(category);
     return this;
   }
 
-  public withScript(script: IScript): this {
+  public withScript(script: Script): this {
     this.scripts.push(script);
     return this;
   }
diff --git a/tests/unit/shared/Stubs/CodeChangedEventStub.ts b/tests/unit/shared/Stubs/CodeChangedEventStub.ts
index c20f3bf9..4f1e884c 100644
--- a/tests/unit/shared/Stubs/CodeChangedEventStub.ts
+++ b/tests/unit/shared/Stubs/CodeChangedEventStub.ts
@@ -1,15 +1,15 @@
 import type { ICodeChangedEvent } from '@/application/Context/State/Code/Event/ICodeChangedEvent';
 import type { ICodePosition } from '@/application/Context/State/Code/Position/ICodePosition';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 
 export class CodeChangedEventStub implements ICodeChangedEvent {
   public code: string;
 
-  public addedScripts: readonly IScript[];
+  public addedScripts: readonly Script[];
 
-  public removedScripts: readonly IScript[];
+  public removedScripts: readonly Script[];
 
-  public changedScripts: readonly IScript[];
+  public changedScripts: readonly Script[];
 
   public isEmpty(): boolean {
     throw new Error('Method not implemented.');
diff --git a/tests/unit/shared/Stubs/CodeSegmentMergerStub.ts b/tests/unit/shared/Stubs/CodeSegmentMergerStub.ts
index 04ec0491..cd437b94 100644
--- a/tests/unit/shared/Stubs/CodeSegmentMergerStub.ts
+++ b/tests/unit/shared/Stubs/CodeSegmentMergerStub.ts
@@ -1,5 +1,5 @@
-import type { CodeSegmentMerger } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/CodeSegmentMerger';
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import type { CodeSegmentMerger } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/CodeSegmentMerger';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
 import { CompiledCodeStub } from './CompiledCodeStub';
 import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 
diff --git a/tests/unit/shared/Stubs/CodeValidationRuleStub.ts b/tests/unit/shared/Stubs/CodeValidationRuleStub.ts
index 978000b9..73a48bc4 100644
--- a/tests/unit/shared/Stubs/CodeValidationRuleStub.ts
+++ b/tests/unit/shared/Stubs/CodeValidationRuleStub.ts
@@ -1,5 +1,5 @@
-import type { ICodeLine } from '@/application/Parser/Script/Validation/ICodeLine';
-import type { ICodeValidationRule, IInvalidCodeLine } from '@/application/Parser/Script/Validation/ICodeValidationRule';
+import type { ICodeLine } from '@/application/Parser/Executable/Script/Validation/ICodeLine';
+import type { ICodeValidationRule, IInvalidCodeLine } from '@/application/Parser/Executable/Script/Validation/ICodeValidationRule';
 
 export class CodeValidationRuleStub implements ICodeValidationRule {
   public readonly receivedLines = new Array<readonly ICodeLine[]>();
diff --git a/tests/unit/shared/Stubs/CodeValidatorStub.ts b/tests/unit/shared/Stubs/CodeValidatorStub.ts
index 0df80477..b68da127 100644
--- a/tests/unit/shared/Stubs/CodeValidatorStub.ts
+++ b/tests/unit/shared/Stubs/CodeValidatorStub.ts
@@ -1,7 +1,7 @@
 import { expect } from 'vitest';
 import type { Constructible } from '@/TypeHelpers';
-import type { ICodeValidationRule } from '@/application/Parser/Script/Validation/ICodeValidationRule';
-import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
+import type { ICodeValidationRule } from '@/application/Parser/Executable/Script/Validation/ICodeValidationRule';
+import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
 
 export class CodeValidatorStub implements ICodeValidator {
   public callHistory = new Array<{
diff --git a/tests/unit/shared/Stubs/CollectionDataStub.ts b/tests/unit/shared/Stubs/CollectionDataStub.ts
index 97378ecf..93a329c7 100644
--- a/tests/unit/shared/Stubs/CollectionDataStub.ts
+++ b/tests/unit/shared/Stubs/CollectionDataStub.ts
@@ -1,7 +1,7 @@
 import type {
   CategoryData, ScriptData, CollectionData, ScriptingDefinitionData, FunctionData,
 } from '@/application/collections/';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
 import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
 import { createScriptDataWithCode } from './ScriptDataStub';
 
diff --git a/tests/unit/shared/Stubs/CompiledCodeStub.ts b/tests/unit/shared/Stubs/CompiledCodeStub.ts
index 38d88d65..5573b97f 100644
--- a/tests/unit/shared/Stubs/CompiledCodeStub.ts
+++ b/tests/unit/shared/Stubs/CompiledCodeStub.ts
@@ -1,4 +1,4 @@
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
 
 export class CompiledCodeStub implements CompiledCode {
   public code = `${CompiledCodeStub.name}: code`;
diff --git a/tests/unit/shared/Stubs/ExecutableErrorContextStub.ts b/tests/unit/shared/Stubs/ExecutableErrorContextStub.ts
new file mode 100644
index 00000000..272359b5
--- /dev/null
+++ b/tests/unit/shared/Stubs/ExecutableErrorContextStub.ts
@@ -0,0 +1,11 @@
+import type { ExecutableErrorContext } from '@/application/Parser/Executable/Validation/ExecutableErrorContext';
+import { ExecutableType } from '@/application/Parser/Executable/Validation/ExecutableType';
+import { CategoryDataStub } from './CategoryDataStub';
+
+export function createExecutableErrorContextStub(): ExecutableErrorContext {
+  return {
+    type: ExecutableType.Category,
+    self: new CategoryDataStub(),
+    parentCategory: new CategoryDataStub(),
+  };
+}
diff --git a/tests/unit/shared/Stubs/NodeDataValidatorStub.ts b/tests/unit/shared/Stubs/ExecutableValidatorStub.ts
similarity index 60%
rename from tests/unit/shared/Stubs/NodeDataValidatorStub.ts
rename to tests/unit/shared/Stubs/ExecutableValidatorStub.ts
index 983b8e14..fc0d846d 100644
--- a/tests/unit/shared/Stubs/NodeDataValidatorStub.ts
+++ b/tests/unit/shared/Stubs/ExecutableValidatorStub.ts
@@ -1,13 +1,13 @@
-import type { NodeData } from '@/application/Parser/NodeValidation/NodeData';
-import type { NodeDataValidator, NodeDataValidatorFactory } from '@/application/Parser/NodeValidation/NodeDataValidator';
+import type { ExecutableData } from '@/application/collections/';
+import type { ExecutableValidator, ExecutableValidatorFactory } from '@/application/Parser/Executable/Validation/ExecutableValidator';
 import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 
-export const createNodeDataValidatorFactoryStub
-: NodeDataValidatorFactory = () => new NodeDataValidatorStub();
+export const createExecutableValidatorFactoryStub
+: ExecutableValidatorFactory = () => new ExecutableValidatorStub();
 
-export class NodeDataValidatorStub
-  extends StubWithObservableMethodCalls<NodeDataValidator>
-  implements NodeDataValidator {
+export class ExecutableValidatorStub
+  extends StubWithObservableMethodCalls<ExecutableValidator>
+  implements ExecutableValidator {
   private assertThrowsOnFalseCondition = true;
 
   public withAssertThrowsOnFalseCondition(enableAssertThrows: boolean): this {
@@ -23,10 +23,10 @@ export class NodeDataValidatorStub
     return this;
   }
 
-  public assertDefined(node: NodeData): this {
+  public assertDefined(data: ExecutableData): this {
     this.registerMethodCall({
       methodName: 'assertDefined',
-      args: [node],
+      args: [data],
     });
     return this;
   }
@@ -41,7 +41,7 @@ export class NodeDataValidatorStub
     });
     if (this.assertThrowsOnFalseCondition) {
       if (!validationPredicate()) {
-        throw new Error(`[${NodeDataValidatorStub.name}] Assert validation failed: ${errorMessage}`);
+        throw new Error(`[${ExecutableValidatorStub.name}] Assert validation failed: ${errorMessage}`);
       }
     }
     return this;
@@ -52,6 +52,6 @@ export class NodeDataValidatorStub
       methodName: 'createContextualErrorMessage',
       args: [errorMessage],
     });
-    return `${NodeDataValidatorStub.name}: ${errorMessage}`;
+    return `${ExecutableValidatorStub.name}: ${errorMessage}`;
   }
 }
diff --git a/tests/unit/shared/Stubs/ExpressionEvaluationContextStub.ts b/tests/unit/shared/Stubs/ExpressionEvaluationContextStub.ts
index 631d1dd8..21e44a2b 100644
--- a/tests/unit/shared/Stubs/ExpressionEvaluationContextStub.ts
+++ b/tests/unit/shared/Stubs/ExpressionEvaluationContextStub.ts
@@ -1,6 +1,6 @@
-import type { IExpressionEvaluationContext } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
-import type { IPipelineCompiler } from '@/application/Parser/Script/Compiler/Expressions/Pipes/IPipelineCompiler';
-import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
+import type { IExpressionEvaluationContext } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
+import type { IPipelineCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipelineCompiler';
+import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
 import { FunctionCallArgumentCollectionStub } from './FunctionCallArgumentCollectionStub';
 import { PipelineCompilerStub } from './PipelineCompilerStub';
 
diff --git a/tests/unit/shared/Stubs/ExpressionParserStub.ts b/tests/unit/shared/Stubs/ExpressionParserStub.ts
index 5e44b93c..a5eef331 100644
--- a/tests/unit/shared/Stubs/ExpressionParserStub.ts
+++ b/tests/unit/shared/Stubs/ExpressionParserStub.ts
@@ -1,5 +1,5 @@
-import type { IExpression } from '@/application/Parser/Script/Compiler/Expressions/Expression/IExpression';
-import type { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
+import type { IExpression } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/IExpression';
+import type { IExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser';
 
 export class ExpressionParserStub implements IExpressionParser {
   public callHistory = new Array<string>();
diff --git a/tests/unit/shared/Stubs/ExpressionStub.ts b/tests/unit/shared/Stubs/ExpressionStub.ts
index 80779096..b4f804fa 100644
--- a/tests/unit/shared/Stubs/ExpressionStub.ts
+++ b/tests/unit/shared/Stubs/ExpressionStub.ts
@@ -1,7 +1,7 @@
-import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
-import type { IExpression } from '@/application/Parser/Script/Compiler/Expressions/Expression/IExpression';
-import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
-import type { IExpressionEvaluationContext } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
+import { ExpressionPosition } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition';
+import type { IExpression } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/IExpression';
+import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
+import type { IExpressionEvaluationContext } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
 import { FunctionParameterCollectionStub } from './FunctionParameterCollectionStub';
 
 export class ExpressionStub implements IExpression {
diff --git a/tests/unit/shared/Stubs/ExpressionsCompilerStub.ts b/tests/unit/shared/Stubs/ExpressionsCompilerStub.ts
index 83bfd0d8..a0880513 100644
--- a/tests/unit/shared/Stubs/ExpressionsCompilerStub.ts
+++ b/tests/unit/shared/Stubs/ExpressionsCompilerStub.ts
@@ -1,7 +1,7 @@
-import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
-import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
+import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
+import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
 import { scrambledEqual } from '@/application/Common/Array';
-import { FunctionBodyType, type ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import { FunctionBodyType, type ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
 import { FunctionCallArgumentCollectionStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub';
 import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 
diff --git a/tests/unit/shared/Stubs/FilterResultStub.ts b/tests/unit/shared/Stubs/FilterResultStub.ts
index b61c0d6f..59c3b4d7 100644
--- a/tests/unit/shared/Stubs/FilterResultStub.ts
+++ b/tests/unit/shared/Stubs/FilterResultStub.ts
@@ -1,13 +1,13 @@
-import type { ICategory } from '@/domain/ICategory';
-import type { IScript } from '@/domain/IScript';
+import type { Category } from '@/domain/Executables/Category/Category';
+import type { Script } from '@/domain/Executables/Script/Script';
 import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { CategoryStub } from './CategoryStub';
 import { ScriptStub } from './ScriptStub';
 
 export class FilterResultStub implements FilterResult {
-  public categoryMatches: readonly ICategory[] = [];
+  public categoryMatches: readonly Category[] = [];
 
-  public scriptMatches: readonly IScript[] = [];
+  public scriptMatches: readonly Script[] = [];
 
   public query = '';
 
@@ -23,12 +23,12 @@ export class FilterResultStub implements FilterResult {
       .withScriptMatches([new ScriptStub('script-2')]);
   }
 
-  public withCategoryMatches(matches: readonly ICategory[]) {
+  public withCategoryMatches(matches: readonly Category[]) {
     this.categoryMatches = matches;
     return this;
   }
 
-  public withScriptMatches(matches: readonly IScript[]) {
+  public withScriptMatches(matches: readonly Script[]) {
     this.scriptMatches = matches;
     return this;
   }
diff --git a/tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub.ts b/tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub.ts
index 75146f6c..fd92c13e 100644
--- a/tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub.ts
+++ b/tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub.ts
@@ -1,5 +1,5 @@
-import type { IFunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgument';
-import type { IFunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
+import type { IFunctionCallArgument } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgument';
+import type { IFunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
 import { FunctionCallArgumentStub } from './FunctionCallArgumentStub';
 
 export class FunctionCallArgumentCollectionStub implements IFunctionCallArgumentCollection {
diff --git a/tests/unit/shared/Stubs/FunctionCallArgumentStub.ts b/tests/unit/shared/Stubs/FunctionCallArgumentStub.ts
index 0ed02a48..9a458a48 100644
--- a/tests/unit/shared/Stubs/FunctionCallArgumentStub.ts
+++ b/tests/unit/shared/Stubs/FunctionCallArgumentStub.ts
@@ -1,4 +1,4 @@
-import type { IFunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgument';
+import type { IFunctionCallArgument } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgument';
 
 export class FunctionCallArgumentStub implements IFunctionCallArgument {
   public parameterName = 'stub-parameter-name';
diff --git a/tests/unit/shared/Stubs/FunctionCallCompilationContextStub.ts b/tests/unit/shared/Stubs/FunctionCallCompilationContextStub.ts
index 51486958..c78e9c2b 100644
--- a/tests/unit/shared/Stubs/FunctionCallCompilationContextStub.ts
+++ b/tests/unit/shared/Stubs/FunctionCallCompilationContextStub.ts
@@ -1,7 +1,7 @@
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import type { SingleCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { SingleCallCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
 import { SingleCallCompilerStub } from './SingleCallCompilerStub';
 import { FunctionCallStub } from './FunctionCallStub';
 import { SharedFunctionCollectionStub } from './SharedFunctionCollectionStub';
diff --git a/tests/unit/shared/Stubs/FunctionCallCompilerStub.ts b/tests/unit/shared/Stubs/FunctionCallCompilerStub.ts
index 4c21ca18..4b2252a0 100644
--- a/tests/unit/shared/Stubs/FunctionCallCompilerStub.ts
+++ b/tests/unit/shared/Stubs/FunctionCallCompilerStub.ts
@@ -1,7 +1,7 @@
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
-import type { FunctionCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler';
-import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import type { FunctionCallCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler';
+import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import { CompiledCodeStub } from './CompiledCodeStub';
 
 interface FunctionCallCompilationTestScenario {
diff --git a/tests/unit/shared/Stubs/FunctionCallStub.ts b/tests/unit/shared/Stubs/FunctionCallStub.ts
index 0b8bc263..adf37b02 100644
--- a/tests/unit/shared/Stubs/FunctionCallStub.ts
+++ b/tests/unit/shared/Stubs/FunctionCallStub.ts
@@ -1,4 +1,4 @@
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import { FunctionCallArgumentCollectionStub } from './FunctionCallArgumentCollectionStub';
 
 export class FunctionCallStub implements FunctionCall {
diff --git a/tests/unit/shared/Stubs/FunctionCodeStub.ts b/tests/unit/shared/Stubs/FunctionCodeStub.ts
index 1dc93cdb..afe25230 100644
--- a/tests/unit/shared/Stubs/FunctionCodeStub.ts
+++ b/tests/unit/shared/Stubs/FunctionCodeStub.ts
@@ -1,4 +1,4 @@
-import type { IFunctionCode } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import type { IFunctionCode } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
 
 export class FunctionCodeStub implements IFunctionCode {
   public execute = 'execute code (function-code-stub)';
diff --git a/tests/unit/shared/Stubs/FunctionParameterCollectionStub.ts b/tests/unit/shared/Stubs/FunctionParameterCollectionStub.ts
index e4eb62fe..01f6cbe7 100644
--- a/tests/unit/shared/Stubs/FunctionParameterCollectionStub.ts
+++ b/tests/unit/shared/Stubs/FunctionParameterCollectionStub.ts
@@ -1,5 +1,5 @@
-import type { IFunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameter';
-import type { IFunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
+import type { IFunctionParameter } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameter';
+import type { IFunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
 import { FunctionParameterStub } from './FunctionParameterStub';
 
 export class FunctionParameterCollectionStub implements IFunctionParameterCollection {
diff --git a/tests/unit/shared/Stubs/FunctionParameterStub.ts b/tests/unit/shared/Stubs/FunctionParameterStub.ts
index 2ddb7df1..8495aee7 100644
--- a/tests/unit/shared/Stubs/FunctionParameterStub.ts
+++ b/tests/unit/shared/Stubs/FunctionParameterStub.ts
@@ -1,4 +1,4 @@
-import type { IFunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameter';
+import type { IFunctionParameter } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameter';
 
 export class FunctionParameterStub implements IFunctionParameter {
   public name = 'function-parameter-stub';
diff --git a/tests/unit/shared/Stubs/LanguageSyntaxStub.ts b/tests/unit/shared/Stubs/LanguageSyntaxStub.ts
index 5be09d13..16e0b041 100644
--- a/tests/unit/shared/Stubs/LanguageSyntaxStub.ts
+++ b/tests/unit/shared/Stubs/LanguageSyntaxStub.ts
@@ -1,4 +1,4 @@
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 
 export class LanguageSyntaxStub implements ILanguageSyntax {
   public commentDelimiters: string[] = [];
diff --git a/tests/unit/shared/Stubs/NodeDataErrorContextStub.ts b/tests/unit/shared/Stubs/NodeDataErrorContextStub.ts
deleted file mode 100644
index eb49c784..00000000
--- a/tests/unit/shared/Stubs/NodeDataErrorContextStub.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import type { NodeDataErrorContext } from '@/application/Parser/NodeValidation/NodeDataErrorContext';
-import { NodeDataType } from '@/application/Parser/NodeValidation/NodeDataType';
-import { CategoryDataStub } from './CategoryDataStub';
-
-export function createNodeDataErrorContextStub(): NodeDataErrorContext {
-  return {
-    type: NodeDataType.Category,
-    selfNode: new CategoryDataStub(),
-    parentNode: new CategoryDataStub(),
-  };
-}
diff --git a/tests/unit/shared/Stubs/PipeFactoryStub.ts b/tests/unit/shared/Stubs/PipeFactoryStub.ts
index 698a511a..6bf550b1 100644
--- a/tests/unit/shared/Stubs/PipeFactoryStub.ts
+++ b/tests/unit/shared/Stubs/PipeFactoryStub.ts
@@ -1,5 +1,5 @@
-import type { IPipe } from '@/application/Parser/Script/Compiler/Expressions/Pipes/IPipe';
-import type { IPipeFactory } from '@/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory';
+import type { IPipe } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipe';
+import type { IPipeFactory } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeFactory';
 
 export class PipeFactoryStub implements IPipeFactory {
   private readonly pipes = new Array<IPipe>();
diff --git a/tests/unit/shared/Stubs/PipeStub.ts b/tests/unit/shared/Stubs/PipeStub.ts
index 8746b877..5981b64a 100644
--- a/tests/unit/shared/Stubs/PipeStub.ts
+++ b/tests/unit/shared/Stubs/PipeStub.ts
@@ -1,4 +1,4 @@
-import type { IPipe } from '@/application/Parser/Script/Compiler/Expressions/Pipes/IPipe';
+import type { IPipe } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipe';
 
 export class PipeStub implements IPipe {
   public name = 'pipeStub';
diff --git a/tests/unit/shared/Stubs/PipelineCompilerStub.ts b/tests/unit/shared/Stubs/PipelineCompilerStub.ts
index eba16a01..b622ad30 100644
--- a/tests/unit/shared/Stubs/PipelineCompilerStub.ts
+++ b/tests/unit/shared/Stubs/PipelineCompilerStub.ts
@@ -1,4 +1,4 @@
-import type { IPipelineCompiler } from '@/application/Parser/Script/Compiler/Expressions/Pipes/IPipelineCompiler';
+import type { IPipelineCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/IPipelineCompiler';
 
 export class PipelineCompilerStub implements IPipelineCompiler {
   public compileHistory: Array<{ value: string, pipeline: string }> = [];
diff --git a/tests/unit/shared/Stubs/ScriptCodeFactoryStub.ts b/tests/unit/shared/Stubs/ScriptCodeFactoryStub.ts
index 9675740e..4ca84745 100644
--- a/tests/unit/shared/Stubs/ScriptCodeFactoryStub.ts
+++ b/tests/unit/shared/Stubs/ScriptCodeFactoryStub.ts
@@ -1,5 +1,5 @@
-import type { ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
-import type { IScriptCode } from '@/domain/IScriptCode';
+import type { ScriptCodeFactory } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
 import { ScriptCodeStub } from './ScriptCodeStub';
 
 export function createScriptCodeFactoryStub(
@@ -17,6 +17,6 @@ export function createScriptCodeFactoryStub(
 }
 
 interface StubOptions {
-  readonly scriptCode?: IScriptCode;
+  readonly scriptCode?: ScriptCode;
   readonly defaultCodePrefix?: string;
 }
diff --git a/tests/unit/shared/Stubs/ScriptCodeStub.ts b/tests/unit/shared/Stubs/ScriptCodeStub.ts
index d77a7413..65829127 100644
--- a/tests/unit/shared/Stubs/ScriptCodeStub.ts
+++ b/tests/unit/shared/Stubs/ScriptCodeStub.ts
@@ -1,6 +1,6 @@
-import type { IScriptCode } from '@/domain/IScriptCode';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
 
-export class ScriptCodeStub implements IScriptCode {
+export class ScriptCodeStub implements ScriptCode {
   public execute = `[${ScriptCodeStub.name}] default execute code`;
 
   public revert = `[${ScriptCodeStub.name}] default revert code`;
diff --git a/tests/unit/shared/Stubs/ScriptCompilerStub.ts b/tests/unit/shared/Stubs/ScriptCompilerStub.ts
index 15cfbe52..7413b543 100644
--- a/tests/unit/shared/Stubs/ScriptCompilerStub.ts
+++ b/tests/unit/shared/Stubs/ScriptCompilerStub.ts
@@ -1,16 +1,16 @@
 import type { ScriptData } from '@/application/collections/';
-import type { IScriptCompiler } from '@/application/Parser/Script/Compiler/IScriptCompiler';
-import type { IScriptCode } from '@/domain/IScriptCode';
+import type { IScriptCompiler } from '@/application/Parser/Executable/Script/Compiler/IScriptCompiler';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
 import { ScriptCodeStub } from './ScriptCodeStub';
 
 export class ScriptCompilerStub implements IScriptCompiler {
-  public compilableScripts = new Map<ScriptData, IScriptCode>();
+  public compilableScripts = new Map<ScriptData, ScriptCode>();
 
   public canCompile(script: ScriptData): boolean {
     return this.compilableScripts.has(script);
   }
 
-  public compile(script: ScriptData): IScriptCode {
+  public compile(script: ScriptData): ScriptCode {
     const foundCode = this.compilableScripts.get(script);
     if (foundCode) {
       return foundCode;
@@ -18,7 +18,7 @@ export class ScriptCompilerStub implements IScriptCompiler {
     return new ScriptCodeStub();
   }
 
-  public withCompileAbility(script: ScriptData, result?: IScriptCode): this {
+  public withCompileAbility(script: ScriptData, result?: ScriptCode): this {
     this.compilableScripts.set(
       script,
       result ?? { execute: `compiled code of ${script.name}`, revert: `compiled revert code of ${script.name}` },
diff --git a/tests/unit/shared/Stubs/ScriptDataStub.ts b/tests/unit/shared/Stubs/ScriptDataStub.ts
index a0b6bff4..d6c7d54a 100644
--- a/tests/unit/shared/Stubs/ScriptDataStub.ts
+++ b/tests/unit/shared/Stubs/ScriptDataStub.ts
@@ -1,7 +1,7 @@
 import type {
   FunctionCallData, CallScriptData, CodeScriptData,
 } from '@/application/collections/';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
 import { FunctionCallDataStub } from '@tests/unit/shared/Stubs/FunctionCallDataStub';
 
 export function createScriptDataWithCode(): ScriptDataStub & CodeScriptData {
diff --git a/tests/unit/shared/Stubs/ScriptFactoryStub.ts b/tests/unit/shared/Stubs/ScriptFactoryStub.ts
index b3a28f62..7fe0c310 100644
--- a/tests/unit/shared/Stubs/ScriptFactoryStub.ts
+++ b/tests/unit/shared/Stubs/ScriptFactoryStub.ts
@@ -1,13 +1,13 @@
-import type { ScriptFactory } from '@/application/Parser/Script/ScriptParser';
-import type { IScript } from '@/domain/IScript';
-import type { ScriptInitParameters } from '@/domain/Script';
+import type { ScriptFactory } from '@/application/Parser/Executable/Script/ScriptParser';
+import type { Script } from '@/domain/Executables/Script/Script';
+import type { ScriptInitParameters } from '@/domain/Executables/Script/CollectionScript';
 import { ScriptStub } from './ScriptStub';
 
 export function createScriptFactorySpy(): {
   readonly scriptFactorySpy: ScriptFactory;
-  getInitParameters: (category: IScript) => ScriptInitParameters | undefined;
+  getInitParameters: (category: Script) => ScriptInitParameters | undefined;
 } {
-  const createdScripts = new Map<IScript, ScriptInitParameters>();
+  const createdScripts = new Map<Script, ScriptInitParameters>();
   return {
     scriptFactorySpy: (parameters) => {
       const script = new ScriptStub('script from factory stub');
diff --git a/tests/unit/shared/Stubs/ScriptParserStub.ts b/tests/unit/shared/Stubs/ScriptParserStub.ts
index 217dbd21..03dec86c 100644
--- a/tests/unit/shared/Stubs/ScriptParserStub.ts
+++ b/tests/unit/shared/Stubs/ScriptParserStub.ts
@@ -1,12 +1,12 @@
-import type { ScriptParser } from '@/application/Parser/Script/ScriptParser';
-import type { IScript } from '@/domain/IScript';
+import type { ScriptParser } from '@/application/Parser/Executable/Script/ScriptParser';
+import type { Script } from '@/domain/Executables/Script/Script';
 import type { ScriptData } from '@/application/collections/';
 import { ScriptStub } from './ScriptStub';
 
 export class ScriptParserStub {
-  private readonly parsedScripts = new Map<IScript, Parameters<ScriptParser>>();
+  private readonly parsedScripts = new Map<Script, Parameters<ScriptParser>>();
 
-  private readonly setupScripts = new Map<ScriptData, IScript>();
+  private readonly setupScripts = new Map<ScriptData, Script>();
 
   public get(): ScriptParser {
     return (...parameters) => {
@@ -21,7 +21,7 @@ export class ScriptParserStub {
   }
 
   public getParseParameters(
-    script: IScript,
+    script: Script,
   ): Parameters<ScriptParser> {
     const parameters = this.parsedScripts.get(script);
     if (!parameters) {
@@ -30,7 +30,7 @@ export class ScriptParserStub {
     return parameters;
   }
 
-  public setupParsedResultForData(scriptData: ScriptData, parsedResult: IScript): this {
+  public setupParsedResultForData(scriptData: ScriptData, parsedResult: Script): this {
     this.setupScripts.set(scriptData, parsedResult);
     return this;
   }
diff --git a/tests/unit/shared/Stubs/ScriptSelectionStub.ts b/tests/unit/shared/Stubs/ScriptSelectionStub.ts
index 5617e950..59f58eaa 100644
--- a/tests/unit/shared/Stubs/ScriptSelectionStub.ts
+++ b/tests/unit/shared/Stubs/ScriptSelectionStub.ts
@@ -1,7 +1,7 @@
 import { expect } from 'vitest';
 import type { ScriptSelection } from '@/application/Context/State/Selection/Script/ScriptSelection';
 import type { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 import type { ScriptSelectionChange, ScriptSelectionChangeCommand } from '@/application/Context/State/Selection/Script/ScriptSelectionChange';
 import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
 import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
@@ -58,7 +58,7 @@ export class ScriptSelectionStub
     });
   }
 
-  public selectOnly(scripts: ReadonlyArray<IScript>): void {
+  public selectOnly(scripts: ReadonlyArray<Script>): void {
     this.registerMethodCall({
       methodName: 'selectOnly',
       args: [scripts],
diff --git a/tests/unit/shared/Stubs/ScriptStub.ts b/tests/unit/shared/Stubs/ScriptStub.ts
index 82e8cfeb..4c447d27 100644
--- a/tests/unit/shared/Stubs/ScriptStub.ts
+++ b/tests/unit/shared/Stubs/ScriptStub.ts
@@ -1,13 +1,13 @@
 import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
-import type { IScript } from '@/domain/IScript';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
-import type { IScriptCode } from '@/domain/IScriptCode';
+import type { Script } from '@/domain/Executables/Script/Script';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
 import { SelectedScriptStub } from './SelectedScriptStub';
 
-export class ScriptStub extends BaseEntity<string> implements IScript {
+export class ScriptStub extends BaseEntity<string> implements Script {
   public name = `name${this.id}`;
 
-  public code: IScriptCode = {
+  public code: ScriptCode = {
     execute: `REM execute-code (${this.id})`,
     revert: `REM revert-code (${this.id})`,
   };
diff --git a/tests/unit/shared/Stubs/SelectedScriptStub.ts b/tests/unit/shared/Stubs/SelectedScriptStub.ts
index fc914ab4..175859e8 100644
--- a/tests/unit/shared/Stubs/SelectedScriptStub.ts
+++ b/tests/unit/shared/Stubs/SelectedScriptStub.ts
@@ -1,15 +1,15 @@
 import type { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
-import type { IScript } from '@/domain/IScript';
+import type { Script } from '@/domain/Executables/Script/Script';
 
 export class SelectedScriptStub implements SelectedScript {
-  public readonly script: IScript;
+  public readonly script: Script;
 
   public readonly id: string;
 
   public revert: boolean;
 
   constructor(
-    script: IScript,
+    script: Script,
   ) {
     this.id = script.id;
     this.script = script;
diff --git a/tests/unit/shared/Stubs/SharedFunctionCollectionStub.ts b/tests/unit/shared/Stubs/SharedFunctionCollectionStub.ts
index bdef0bae..df1f4c93 100644
--- a/tests/unit/shared/Stubs/SharedFunctionCollectionStub.ts
+++ b/tests/unit/shared/Stubs/SharedFunctionCollectionStub.ts
@@ -1,5 +1,5 @@
-import type { ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
+import type { ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
+import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
 import { createSharedFunctionStubWithCode } from './SharedFunctionStub';
 
 export class SharedFunctionCollectionStub implements ISharedFunctionCollection {
diff --git a/tests/unit/shared/Stubs/SharedFunctionStub.ts b/tests/unit/shared/Stubs/SharedFunctionStub.ts
index 1ed51ec0..8de9a3e3 100644
--- a/tests/unit/shared/Stubs/SharedFunctionStub.ts
+++ b/tests/unit/shared/Stubs/SharedFunctionStub.ts
@@ -1,8 +1,8 @@
 import {
   type ISharedFunction, FunctionBodyType, type CallFunctionBody, type CodeFunctionBody,
-} from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+} from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
+import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import { FunctionParameterCollectionStub } from './FunctionParameterCollectionStub';
 import { FunctionCallStub } from './FunctionCallStub';
 import { FunctionCodeStub } from './FunctionCodeStub';
diff --git a/tests/unit/shared/Stubs/SharedFunctionsParserStub.ts b/tests/unit/shared/Stubs/SharedFunctionsParserStub.ts
index f0c28d8f..50418c81 100644
--- a/tests/unit/shared/Stubs/SharedFunctionsParserStub.ts
+++ b/tests/unit/shared/Stubs/SharedFunctionsParserStub.ts
@@ -1,8 +1,8 @@
 import type { FunctionData } from '@/application/collections/';
 import { sequenceEqual } from '@/application/Common/Array';
-import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
-import type { ISharedFunctionsParser } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionsParser';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
+import type { ISharedFunctionsParser } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionsParser';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 import { SharedFunctionCollectionStub } from './SharedFunctionCollectionStub';
 
 export class SharedFunctionsParserStub implements ISharedFunctionsParser {
diff --git a/tests/unit/shared/Stubs/SingleCallCompilerStrategyStub.ts b/tests/unit/shared/Stubs/SingleCallCompilerStrategyStub.ts
index bdfe4725..eab07038 100644
--- a/tests/unit/shared/Stubs/SingleCallCompilerStrategyStub.ts
+++ b/tests/unit/shared/Stubs/SingleCallCompilerStrategyStub.ts
@@ -1,8 +1,8 @@
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import type { SingleCallCompilerStrategy } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { SingleCallCompilerStrategy } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
 import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 import { CompiledCodeStub } from './CompiledCodeStub';
 
diff --git a/tests/unit/shared/Stubs/SingleCallCompilerStub.ts b/tests/unit/shared/Stubs/SingleCallCompilerStub.ts
index eb2f3783..e68db5fc 100644
--- a/tests/unit/shared/Stubs/SingleCallCompilerStub.ts
+++ b/tests/unit/shared/Stubs/SingleCallCompilerStub.ts
@@ -1,7 +1,7 @@
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import type { SingleCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { SingleCallCompiler } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 import { CompiledCodeStub } from './CompiledCodeStub';
 
diff --git a/tests/unit/shared/Stubs/SyntaxFactoryStub.ts b/tests/unit/shared/Stubs/SyntaxFactoryStub.ts
new file mode 100644
index 00000000..59e07964
--- /dev/null
+++ b/tests/unit/shared/Stubs/SyntaxFactoryStub.ts
@@ -0,0 +1,18 @@
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
+import type { ISyntaxFactory } from '@/application/Parser/Executable/Script/Validation/Syntax/ISyntaxFactory';
+import type { ScriptingLanguage } from '@/domain/ScriptingLanguage';
+import { LanguageSyntaxStub } from './LanguageSyntaxStub';
+
+export function createSyntaxFactoryStub(
+  expectedLanguage?: ScriptingLanguage,
+  result?: ILanguageSyntax,
+): ISyntaxFactory {
+  return {
+    create: (language: ScriptingLanguage) => {
+      if (expectedLanguage !== undefined && language !== expectedLanguage) {
+        throw new Error('unexpected language');
+      }
+      return result ?? new LanguageSyntaxStub();
+    },
+  };
+}